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

refactor: 💥 q_* UDL renamed to _q_*

Browse Source 
We had some fun exploring the STD UDLs for potential collisions,
we have learnt our lesson and know how to proceed.
Now is high time to start behaving and obeying C++ rules.
This commit is contained in:
Mateusz Pusz
2020-09-09 19:20:35 +02:00
parent 2b408f19c0
commit 9527b39005
130 changed files with 2221 additions and 2235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
README.md
View File

@ -27,22 +27,22 @@ Here is a small example of possible operations:
```cpp ```cpp
// simple numeric operations // simple numeric operations
static_assert(10q_km / 2 == 5q_km); static_assert(10_q_km / 2 == 5_q_km);
// unit conversions // unit conversions
static_assert(1q_h == 3600q_s); static_assert(1_q_h == 3600_q_s);
static_assert(1q_km + 1q_m == 1001q_m); static_assert(1_q_km + 1_q_m == 1001_q_m);
// dimension conversions // dimension conversions
static_assert(1q_km / 1q_s == 1000q_m_per_s); static_assert(1_q_km / 1_q_s == 1000_q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km); static_assert(2_q_km_per_h * 2_q_h == 4_q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h); static_assert(2_q_km / 2_q_km_per_h == 1_q_h);
static_assert(2q_m * 3q_m == 6q_m2); static_assert(2_q_m * 3_q_m == 6_q_m2);
static_assert(10q_km / 5q_km == 2); static_assert(10_q_km / 5_q_km == 2);
static_assert(1000 / 1q_s == 1q_kHz); static_assert(1000 / 1_q_s == 1_q_kHz);
``` ```
_Try it on the [Compiler Explorer](https://godbolt.org/z/XPmjPz)._ _Try it on the [Compiler Explorer](https://godbolt.org/z/XPmjPz)._
@ -68,7 +68,7 @@ constexpr Speed auto avg_speed(Length auto d, Time auto t)
int main() int main()
{ {
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
Speed auto v1 = avg_speed(220q_km, 2q_h); Speed auto v1 = avg_speed(220_q_km, 2_q_h);
Speed auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2)); Speed auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2));
Speed auto v3 = quantity_cast<si::metre_per_second>(v2); Speed auto v3 = quantity_cast<si::metre_per_second>(v2);
Speed auto v4 = quantity_cast<int>(v3); Speed auto v4 = quantity_cast<int>(v3);

6
conanfile.py
View File

@ -115,11 +115,9 @@ class UnitsConan(ConanFile):
version = Version(self.settings.compiler.version) version = Version(self.settings.compiler.version)
if compiler == "gcc": if compiler == "gcc":
self.cpp_info.cxxflags = [ self.cpp_info.cxxflags = [
"-Wno-literal-suffix", "-Wno-non-template-friend"
"-Wno-non-template-friend",
] ]
elif compiler == "Visual Studio": elif compiler == "Visual Studio":
self.cpp_info.cxxflags = [ self.cpp_info.cxxflags = [
"/utf-8", "/utf-8"
"/wd4455"
] ]

1
docs/CHANGELOG.md
View File

@ -19,6 +19,7 @@
- Added support for `exp()` mathematical support - Added support for `exp()` mathematical support
- Dimensionless quantities redesigned to be of `quantity` type - Dimensionless quantities redesigned to be of `quantity` type
- `Scalar` concept renamed to `ScalableNumber` - `Scalar` concept renamed to `ScalableNumber`
- `q_*` UDL renamed to `_q_*`
- **0.5.0 May 17, 2020** - **0.5.0 May 17, 2020**
- Major refactoring and rewrite of the library - Major refactoring and rewrite of the library

29
docs/faq.rst
View File

@ -36,7 +36,7 @@ Why a dimensionless quantity is not just an fundamental arithmetic type?
In the initial design of this library the resulting type of the division of In the initial design of this library the resulting type of the division of
two quantities was their common representation type:: two quantities was their common representation type::
static_assert(std::is_same_v<decltype(10q_km / 5q_km), std::int64_t>); static_assert(std::is_same_v<decltype(10_q_km / 5_q_km), std::int64_t>);
The reasoning behind it was to not provide a false impression of a strong `quantity` type The reasoning behind it was to not provide a false impression of a strong `quantity` type
for something that looks and feels like a regular number. Also all of the mathematic for something that looks and feels like a regular number. Also all of the mathematic
@ -67,8 +67,13 @@ Well, this is how [ISO-80000]_ defines it (British English spelling by default).
User Defined Literals (UDLs) User Defined Literals (UDLs)
---------------------------- ----------------------------
Why all UDLs are prefixed with ``q_`` instead of just using unit symbol? Why all UDLs are prefixed with ``_q_`` instead of just using unit symbol?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
..note ..
Every ``_q_*`` UDL will be replaced by the ``q_*`` literal when/if **mp-units**
will become a part of the C++ Standard Library.
Usage of only unit symbols in UDLs would be a preferred approach (less to type, Usage of only unit symbols in UDLs would be a preferred approach (less to type,
easier to understand and maintain). However, while increasing the coverage for easier to understand and maintain). However, while increasing the coverage for
@ -77,26 +82,10 @@ built-in types or numeric extensions. A few of those are: ``F`` (farad),
``J`` (joule), ``W`` (watt), ``K`` (kelvin), ``d`` (day), ``J`` (joule), ``W`` (watt), ``K`` (kelvin), ``d`` (day),
``l`` or ``L`` (litre), ``erg``, ``ergps``. For a while for those we used ``_`` ``l`` or ``L`` (litre), ``erg``, ``ergps``. For a while for those we used ``_``
prefix to make the library work at all, but at some point we had to unify the prefix to make the library work at all, but at some point we had to unify the
naming and we came up with ``q_`` prefix which results in a creation of naming and we came up with ``_q_`` prefix which results in a creation of
quantity of a provided unit. quantity of a provided unit.
Why do we use UDLs reserved for the C++ standard (no ``_`` prefix)?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This library is meant to become a part of the C++ Standard Library at some point
in the future. We decided to work with the target interface to get implementation
and user experience. Only thanks to this we were able to detect multiple collisions
with literals already existing in the language in our initial approach
(`Why all UDLs are prefixed with q_ instead of just using unit symbol?
<#why-unicode-quantity-symbols-are-used-by-default-instead-of-ascii-only-characters>`_).
This approach has some side effects though. We had to disable some compiler warnings
to make it work:
- ``/wd4455`` on MSVC,
- ``-Wno-literal-suffix`` on other compilers.
Text formatting Text formatting
--------------- ---------------

46
docs/framework/conversions_and_casting.rst
View File

@ -21,9 +21,9 @@ No Conversions
No conversions (either implicit or explicit) are available across quantities of No conversions (either implicit or explicit) are available across quantities of
different dimensions:: different dimensions::
si::length<si::metre> d1 = 1q_s; // Compile-time error si::length<si::metre> d1 = 1_q_s; // Compile-time error
si::length<si::metre> d2(1q_s); // Compile-time error si::length<si::metre> d2(1_q_s); // Compile-time error
auto d3 = quantity_cast<si::metre>(1q_s); // Compile-time error auto d3 = quantity_cast<si::metre>(1_q_s); // Compile-time error
Implicit Implicit
@ -33,23 +33,23 @@ Implicit conversions are allowed only across quantities of the same dimension:
- for integral types with ratios that guarantee no precision loss:: - for integral types with ratios that guarantee no precision loss::
si::length<si::metre, int> d1 = 1q_km + 1q_m; // OK si::length<si::metre, int> d1 = 1_q_km + 1_q_m; // OK
si::length<si::millimetre, int> d2 = 1q_km + 1q_m; // OK si::length<si::millimetre, int> d2 = 1_q_km + 1_q_m; // OK
si::length<si::kilometre, int> d3 = 1q_km + 1q_m; // Compile-time error si::length<si::kilometre, int> d3 = 1_q_km + 1_q_m; // Compile-time error
si::length<si::kilometre, int> d4(1q_km + 1q_m); // Compile-time error si::length<si::kilometre, int> d4(1_q_km + 1_q_m); // Compile-time error
si::length<si::metre, int> d5 = 1q_m + 1q_ft; // Compile-time error si::length<si::metre, int> d5 = 1_q_m + 1_q_ft; // Compile-time error
si::length<si::metre, int> d6(1q_m + 1q_ft); // Compile-time error si::length<si::metre, int> d6(1_q_m + 1_q_ft); // Compile-time error
- from an integral to a floating-point representation even in case of a truncating - from an integral to a floating-point representation even in case of a truncating
ratio:: ratio::
si::length<si::kilometre, double> d7 = 1q_km + 1q_m; // OK si::length<si::kilometre, double> d7 = 1_q_km + 1_q_m; // OK
si::length<si::metre, double> d8 = 1q_m + 1q_ft; // OK si::length<si::metre, double> d8 = 1_q_m + 1_q_ft; // OK
- when both sides use a floating-point representation:: - when both sides use a floating-point representation::
si::length<si::metre, int> d9 = 1.23q_m; // Compile-time error si::length<si::metre, int> d9 = 1.23_q_m; // Compile-time error
si::length<si::metre, double> d10 = 1.23q_m; // OK si::length<si::metre, double> d10 = 1.23_q_m; // OK
Explicit Explicit
@ -92,7 +92,7 @@ once and leave the rest intact:
`quantity_point_cast` takes anything that works for `quantity_point` `quantity_point_cast` takes anything that works for `quantity_point`
or a specific target `quantity_point`:: or a specific target `quantity_point`::
std::cout << "Point: " << quantity_point_cast<decltype(quantity_point{0q_m})>(d) << '\n'; std::cout << "Point: " << quantity_point_cast<decltype(quantity_point{0_q_m})>(d) << '\n';
.. seealso:: .. seealso::
@ -108,8 +108,8 @@ As noted in the :ref:`Dimensionless Quantities` chapter, :term:`quantity of dime
is somehow special but still obey most of the rules defined for quantities. However, as they is somehow special but still obey most of the rules defined for quantities. However, as they
represent numbers it would be highly uncomfortable to every time type:: represent numbers it would be highly uncomfortable to every time type::
const auto d1 = 10q_km; const auto d1 = 10_q_km;
const auto d2 = 3q_km; const auto d2 = 3_q_km;
if(d1 / d2 > dimensionless<one, 2>) { if(d1 / d2 > dimensionless<one, 2>) {
// ... // ...
} }
@ -123,8 +123,8 @@ This is why it was decided to allow the ``dimensionless<one>`` quantity of any
representation type to be implicitly constructible from this representation type. representation type to be implicitly constructible from this representation type.
With that the above examples can be rewritten as follows:: With that the above examples can be rewritten as follows::
const auto d1 = 10q_km; const auto d1 = 10_q_km;
const auto d2 = 3q_km; const auto d2 = 3_q_km;
if(d1 / d2 > 2) { if(d1 / d2 > 2) {
// ... // ...
} }
@ -142,8 +142,8 @@ could be ambiguous. For example::
return d1 / d2 + 1; return d1 / d2 + 1;
} }
As long as we can reason about what such code means for ``foo(10q_km, 2q_km)`` it is not that obvious As long as we can reason about what such code means for ``foo(10_q_km, 2_q_km)`` it is not that obvious
at all in the case of ``foo(10q_cm, 2q_ft)``. To make such code to compile for every case we have to at all in the case of ``foo(10_q_cm, 2_q_ft)``. To make such code to compile for every case we have to
either change the type of the resulting unit to the one having ``ratio(1)`` (:term:`coherent derived unit`):: either change the type of the resulting unit to the one having ``ratio(1)`` (:term:`coherent derived unit`)::
Dimensionless auto foo(Length auto d1, Length auto d2) Dimensionless auto foo(Length auto d1, Length auto d2)
@ -162,15 +162,15 @@ There is one more important point to note here. As the the dimensionless quantit
a number, it is never implicitly converted back to the representation type. This means that the following a number, it is never implicitly converted back to the representation type. This means that the following
code will not compile:: code will not compile::
auto v = std::exp(10q_m / 5q_m); auto v = std::exp(10_q_m / 5_q_m);
To make it compile fine we have to either explicitly get the value stored in the quantity:: To make it compile fine we have to either explicitly get the value stored in the quantity::
auto v = std::exp(quantity_cast<one>(10q_m / 5q_m).count()); auto v = std::exp(quantity_cast<one>(10_q_m / 5_q_m).count());
or use a mathematical wrapper function from `units` namespace:: or use a mathematical wrapper function from `units` namespace::
auto v = units::exp(10q_m / 5q_m); auto v = units::exp(10_q_m / 5_q_m);
.. important:: .. important::

30
docs/framework/dimensions.rst
View File

@ -17,8 +17,8 @@ each other and the result will always be a quantity of the same dimension:
.. code-block:: .. code-block::
:emphasize-lines: 3-4 :emphasize-lines: 3-4
Length auto dist1 = 2q_m; Length auto dist1 = 2_q_m;
Length auto dist2 = 1q_m; Length auto dist2 = 1_q_m;
Length auto res1 = dist1 + dist2; Length auto res1 = dist1 + dist2;
Length auto res2 = dist1 - dist2; Length auto res2 = dist1 - dist2;
@ -29,7 +29,7 @@ not change:
.. code-block:: .. code-block::
:emphasize-lines: 2-4 :emphasize-lines: 2-4
Length auto dist = 2q_m; Length auto dist = 2_q_m;
Length auto res1 = dist * 2; // 4 m Length auto res1 = dist * 2; // 4 m
Length auto res2 = 3 * res1; // 12 m Length auto res2 = 3 * res1; // 12 m
Length auto res3 = res2 / 2; // 6 m Length auto res3 = res2 / 2; // 6 m
@ -41,9 +41,9 @@ probably will always end up in a quantity of a yet another dimension:
.. code-block:: .. code-block::
:emphasize-lines: 4-6 :emphasize-lines: 4-6
Length auto dist1 = 2q_m; Length auto dist1 = 2_q_m;
Length auto dist2 = 3q_m; Length auto dist2 = 3_q_m;
Time auto dur1 = 2q_s; Time auto dur1 = 2_q_s;
Area auto res1 = dist1 * dist2; // 6 m² Area auto res1 = dist1 * dist2; // 6 m²
Speed auto res2 = dist1 / dur1; // 1 m/s Speed auto res2 = dist1 / dur1; // 1 m/s
Frequency auto res3 = 10 / dur1; // 5 Hz Frequency auto res3 = 10 / dur1; // 5 Hz
@ -55,9 +55,9 @@ dimension, than we will end up with just a scalable number type:
.. code-block:: .. code-block::
:emphasize-lines: 4-5 :emphasize-lines: 4-5
Time auto dur1 = 10q_s; Time auto dur1 = 10_q_s;
Time auto dur2 = 2q_s; Time auto dur2 = 2_q_s;
Frequency auto fr1 = 5q_Hz; Frequency auto fr1 = 5_q_Hz;
ScalableNumber auto v1 = dur1 / dur2; // 5 ScalableNumber auto v1 = dur1 / dur2; // 5
ScalableNumber auto v2 = dur1 * fr1; // 50 ScalableNumber auto v2 = dur1 * fr1; // 50
@ -69,8 +69,8 @@ The result will always be a quantity point of the same dimension:
.. code-block:: .. code-block::
:emphasize-lines: 3-5 :emphasize-lines: 3-5
Length auto dist1 = 2q_m; Length auto dist1 = 2_q_m;
Length auto dist2 = 1q_m; Length auto dist2 = 1_q_m;
QuantityPoint auto res1 = quantity_point{dist1} + dist2; QuantityPoint auto res1 = quantity_point{dist1} + dist2;
QuantityPoint auto res2 = dist1 + quantity_point{dist2}; QuantityPoint auto res2 = dist1 + quantity_point{dist2};
QuantityPoint auto res3 = quantity_point{dist1} - dist2; QuantityPoint auto res3 = quantity_point{dist1} - dist2;
@ -82,8 +82,8 @@ The result will always be a quantity point of the same dimension:
.. code-block:: .. code-block::
:emphasize-lines: 3 :emphasize-lines: 3
Length auto dist1 = 2q_m; Length auto dist1 = 2_q_m;
Length auto dist2 = 1q_m; Length auto dist2 = 1_q_m;
auto res1 = dist1 - quantity_point{dist2}; // ERROR auto res1 = dist1 - quantity_point{dist2}; // ERROR
We can also subtract two quantity points. We can also subtract two quantity points.
@ -92,8 +92,8 @@ The result is a relative quantity of the same dimension:
.. code-block:: .. code-block::
:emphasize-lines: 3 :emphasize-lines: 3
Length auto dist1 = 2q_m; Length auto dist1 = 2_q_m;
Length auto dist2 = 1q_m; Length auto dist2 = 1_q_m;
Length auto res1 = quantity_point{dist1} - quantity_point{dist2}; Length auto res1 = quantity_point{dist1} - quantity_point{dist2};
That's it! You can't multiply nor divide quantity points with anything else. That's it! You can't multiply nor divide quantity points with anything else.

26
docs/framework/quantities.rst
View File

@ -48,15 +48,15 @@ values the library provides :abbr:`UDL (User Defined Literal)` s for each
be as simple as:: be as simple as::
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
constexpr auto d1 = 123q_km; // si::length<si::kilometre, std::int64_t> constexpr auto d1 = 123_q_km; // si::length<si::kilometre, std::int64_t>
constexpr auto d2 = 123.q_km; // si::length<si::kilometre, long double> constexpr auto d2 = 123._q_km; // si::length<si::kilometre, long double>
``123q_km`` should be read as a quantity of length in kilometers. Initially the ``123_q_km`` should be read as a quantity of length in kilometers. Initially the
library did not use the ``q_`` prefix for UDLs but it turned out that there are library did not use the ``_q_`` prefix for UDLs but it turned out that there are
a few unit symbols that collide with literals already existing in C and C++ a few unit symbols that collide with literals already existing in C and C++
language (i.e. ``F`` (farad), ``J`` (joule), ``W`` (watt), ``K`` (kelvin), language (i.e. ``F`` (farad), ``J`` (joule), ``W`` (watt), ``K`` (kelvin),
``d`` (day), ``l`` or ``L`` (litre), ``erg``, ``ergps``). This is why the ``d`` (day), ``l`` or ``L`` (litre), ``erg``, ``ergps``). This is why the
``q_`` prefix was consistently applied to all the UDLs. ``_q_`` prefix was consistently applied to all the UDLs.
Dimension-specific Concepts Dimension-specific Concepts
@ -67,7 +67,7 @@ requires quantity of a concrete dimension than dimension-specific concepts can
be used:: be used::
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
constexpr Length auto d = 123q_km; // si::length<si::kilometre, std::int64_t> constexpr Length auto d = 123_q_km; // si::length<si::kilometre, std::int64_t>
.. note:: .. note::
@ -83,8 +83,8 @@ quantities. The usage of such a function can look as follows::
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
using namespace units::physical::international::literals; using namespace units::physical::international::literals;
constexpr Speed auto v1 = avg_speed(220q_km, 2q_h); constexpr Speed auto v1 = avg_speed(220_q_km, 2_q_h);
constexpr Speed auto v2 = avg_speed(140q_mi, 2q_h); constexpr Speed auto v2 = avg_speed(140_q_mi, 2_q_h);
In this and all other physical units libraries such a function can be In this and all other physical units libraries such a function can be
implemented as:: implemented as::
@ -142,7 +142,7 @@ but often we would like to know a specific type too. We have two options here:
- query the actual dimension, unit, and representation types:: - query the actual dimension, unit, and representation types::
constexpr Speed auto v = avg_speed(220q_km, 2q_h); constexpr Speed auto v = avg_speed(220_q_km, 2_q_h);
using quantity_type = decltype(v); using quantity_type = decltype(v);
using dimension_type = quantity_type::dimension; using dimension_type = quantity_type::dimension;
using unit_type = quantity_type::unit; using unit_type = quantity_type::unit;
@ -150,7 +150,7 @@ but often we would like to know a specific type too. We have two options here:
- convert or cast to a desired quantity type:: - convert or cast to a desired quantity type::
constexpr Speed auto v1 = avg_speed(220.q_km, 2q_h); constexpr Speed auto v1 = avg_speed(220._q_km, 2_q_h);
constexpr si::speed<si::metre_per_second> v2 = v1; constexpr si::speed<si::metre_per_second> v2 = v1;
constexpr Speed auto v3 = quantity_cast<si::speed<si::metre_per_second>(v1); constexpr Speed auto v3 = quantity_cast<si::speed<si::metre_per_second>(v1);
@ -166,8 +166,8 @@ Dimensionless Quantities
Whenever we divide two quantities of the same dimension we end up with a Whenever we divide two quantities of the same dimension we end up with a
:term:`dimensionless quantity` otherwise known as :term:`quantity of dimension one`:: :term:`dimensionless quantity` otherwise known as :term:`quantity of dimension one`::
static_assert(10q_km / 5q_km == 2); static_assert(10_q_km / 5_q_km == 2);
static_assert(std::is_same_v<decltype(10q_km / 5q_km), quantity<dim_one, one, std::int64_t>>); static_assert(std::is_same_v<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
According to the official ISO definition `dim_one` is a dimension "for which all the According to the official ISO definition `dim_one` is a dimension "for which all the
exponents of the factors corresponding to the base quantities in its quantity dimension exponents of the factors corresponding to the base quantities in its quantity dimension
@ -196,7 +196,7 @@ There are two special units provided for usage with such a quantity:
For example the following code:: For example the following code::
std::cout << quantity_cast<percent>(50.q_m / 100.q_m) << '\n'; std::cout << quantity_cast<percent>(50._q_m / 100._q_m) << '\n';
will print ``50 %`` to the console output. will print ``50 %`` to the console output.

4
docs/framework/quantity_points.rst
View File

@ -14,7 +14,7 @@ Quantity Point Construction
To create the quantity point object from a `quantity` we just have to pass To create the quantity point object from a `quantity` we just have to pass
the value to the `quantity_point` class template explicit constructor:: the value to the `quantity_point` class template explicit constructor::
quantity_point<si::dim_length, si::kilometre, double> d(123q_km); quantity_point<si::dim_length, si::kilometre, double> d(123_q_km);
.. note:: .. note::
@ -25,7 +25,7 @@ the value to the `quantity_point` class template explicit constructor::
`copy initialization <https://en.cppreference.com/w/cpp/language/copy_initialization>`_ `copy initialization <https://en.cppreference.com/w/cpp/language/copy_initialization>`_
**does not compile**:: **does not compile**::
quantity_point<si::dim_length, si::kilometre, double> d = 123q_km; // ERROR quantity_point<si::dim_length, si::kilometre, double> d = 123_q_km; // ERROR
Differences to quantity Differences to quantity

122
docs/framework/text_output.rst
View File

@ -18,8 +18,8 @@ stream::
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
using namespace units::physical::international::literals; using namespace units::physical::international::literals;
constexpr Speed auto v1 = avg_speed(220.q_km, 2q_h); constexpr Speed auto v1 = avg_speed(220._q_km, 2_q_h);
constexpr Speed auto v2 = avg_speed(140.q_mi, 2q_h); constexpr Speed auto v2 = avg_speed(140._q_mi, 2_q_h);
std::cout << v1 << '\n'; // 110 km/h std::cout << v1 << '\n'; // 110 km/h
std::cout << v2 << '\n'; // 70 mi/h std::cout << v2 << '\n'; // 70 mi/h
@ -41,9 +41,9 @@ Stream Output Formatting
Only a basic formatting can be applied for output streams. It includes control Only a basic formatting can be applied for output streams. It includes control
over width, fill, and alignment:: over width, fill, and alignment::
os << "|" << std::setw(10) << 123q_m << "|"; // | 123 m| os << "|" << std::setw(10) << 123_q_m << "|"; // | 123 m|
os << "|" << std::setw(10) << std::left << 123q_m << "|"; // |123 m | os << "|" << std::setw(10) << std::left << 123_q_m << "|"; // |123 m |
os << "|" << std::setw(10) << std::setfill('*') << 123q_m << "|"; // |*****123 m| os << "|" << std::setw(10) << std::setfill('*') << 123_q_m << "|"; // |*****123 m|
fmt::format fmt::format
@ -91,9 +91,9 @@ In case it is left empty the default formatting of ``{:%Q %q}`` is applied. The
default formatting is also applied to the output streams. This is why the following default formatting is also applied to the output streams. This is why the following
code lines produce the same output:: code lines produce the same output::
std::cout << "Distance: " << 123q_km << "\n"; std::cout << "Distance: " << 123_q_km << "\n";
fmt::print("Distance: {}\n", 123q_km); fmt::print("Distance: {}\n", 123_q_km);
fmt::print("Distance: {:%Q %q}\n", 123q_km); fmt::print("Distance: {:%Q %q}\n", 123_q_km);
Quantity Value, Symbol, or Both? Quantity Value, Symbol, or Both?
@ -102,9 +102,9 @@ Quantity Value, Symbol, or Both?
The user can easily decide to either print a whole quantity (value and symbol) or The user can easily decide to either print a whole quantity (value and symbol) or
only its parts. Also a different quantity formatting might be applied:: only its parts. Also a different quantity formatting might be applied::
fmt::print("{:%Q}", 123q_km); // 123 fmt::print("{:%Q}", 123_q_km); // 123
fmt::print("{:%q}", 123q_km); // km fmt::print("{:%q}", 123_q_km); // km
fmt::print("{:%Q%q}", 123q_km); // 123km fmt::print("{:%Q%q}", 123_q_km); // 123km
Controlling Width, Fill, and Alignment Controlling Width, Fill, and Alignment
@ -114,14 +114,14 @@ To control width, fill, and alignment the C++ standard grammar tokens ``fill-and
and ``width`` are being used and they treat a quantity value and symbol as a contiguous and ``width`` are being used and they treat a quantity value and symbol as a contiguous
text:: text::
fmt::print("|{:0}|", 123q_m); // |123 m| fmt::print("|{:0}|", 123_q_m); // |123 m|
fmt::print("|{:10}|", 123q_m); // | 123 m| fmt::print("|{:10}|", 123_q_m); // | 123 m|
fmt::print("|{:<10}|", 123q_m); // |123 m | fmt::print("|{:<10}|", 123_q_m); // |123 m |
fmt::print("|{:>10}|", 123q_m); // | 123 m| fmt::print("|{:>10}|", 123_q_m); // | 123 m|
fmt::print("|{:^10}|", 123q_m); // | 123 m | fmt::print("|{:^10}|", 123_q_m); // | 123 m |
fmt::print("|{:*<10}|", 123q_m); // |123 m*****| fmt::print("|{:*<10}|", 123_q_m); // |123 m*****|
fmt::print("|{:*>10}|", 123q_m); // |*****123 m| fmt::print("|{:*>10}|", 123_q_m); // |*****123 m|
fmt::print("|{:*^10}|", 123q_m); // |**123 m***| fmt::print("|{:*^10}|", 123_q_m); // |**123 m***|
ASCII-only Quantity Symbols ASCII-only Quantity Symbols
@ -133,12 +133,12 @@ this by default. From the engineering point of view sometimes Unicode text migh
not be a solution as terminals of many (especially embedded) devices are ASCII-only. not be a solution as terminals of many (especially embedded) devices are ASCII-only.
In such a case the unit symbol can be forced to be printed using ASCII-only characters:: In such a case the unit symbol can be forced to be printed using ASCII-only characters::
fmt::print("{}", 10q_R); // 10 Ω fmt::print("{}", 10_q_R); // 10 Ω
fmt::print("{:%Q %Aq}", 10q_R); // 10 ohm fmt::print("{:%Q %Aq}", 10_q_R); // 10 ohm
fmt::print("{}", 125q_us); // 125 µs fmt::print("{}", 125_q_us); // 125 µs
fmt::print("{:%Q %Aq}", 125q_us); // 125 us fmt::print("{:%Q %Aq}", 125_q_us); // 125 us
fmt::print("{}", 9.8q_m_per_s2); // 9.8 m/s² fmt::print("{}", 9.8_q_m_per_s2); // 9.8 m/s²
fmt::print("{:%Q %Aq}", 9.8q_m_per_s2); // 9.8 m/s^2 fmt::print("{:%Q %Aq}", 9.8_q_m_per_s2); // 9.8 m/s^2
Controlling on How the Quantity Value Is Being Printed Controlling on How the Quantity Value Is Being Printed
@ -146,8 +146,8 @@ Controlling on How the Quantity Value Is Being Printed
``sign`` token allows us to specify on how the value's sign is being printed:: ``sign`` token allows us to specify on how the value's sign is being printed::
fmt::print("{0:%Q %q},{0:%+Q %q},{0:%-Q %q},{0:% Q %q}", 1q_m); // 1 m,+1 m,1 m, 1 m fmt::print("{0:%Q %q},{0:%+Q %q},{0:%-Q %q},{0:% Q %q}", 1_q_m); // 1 m,+1 m,1 m, 1 m
fmt::print("{0:%Q %q},{0:%+Q %q},{0:%-Q %q},{0:% Q %q}", -1q_m); // -1 m,-1 m,-1 m,-1 m fmt::print("{0:%Q %q},{0:%+Q %q},{0:%-Q %q},{0:% Q %q}", -1_q_m); // -1 m,-1 m,-1 m,-1 m
where: where:
@ -159,47 +159,47 @@ where:
``precision`` token is allowed only for floating-point representation types:: ``precision`` token is allowed only for floating-point representation types::
fmt::print("{:%.0Q %q}", 1.2345q_m); // 1 m fmt::print("{:%.0Q %q}", 1.2345_q_m); // 1 m
fmt::print("{:%.1Q %q}", 1.2345q_m); // 1.2 m fmt::print("{:%.1Q %q}", 1.2345_q_m); // 1.2 m
fmt::print("{:%.2Q %q}", 1.2345q_m); // 1.23 m fmt::print("{:%.2Q %q}", 1.2345_q_m); // 1.23 m
:token:`units-rep-type` specifies how a value of the representation type is being :token:`units-rep-type` specifies how a value of the representation type is being
printed. For integral types:: printed. For integral types::
fmt::print("{:%bQ %q}", 42q_m); // 101010 m fmt::print("{:%bQ %q}", 42_q_m); // 101010 m
fmt::print("{:%BQ %q}", 42q_m); // 101010 m fmt::print("{:%BQ %q}", 42_q_m); // 101010 m
fmt::print("{:%dQ %q}", 42q_m); // 42 m fmt::print("{:%dQ %q}", 42_q_m); // 42 m
fmt::print("{:%oQ %q}", 42q_m); // 52 m fmt::print("{:%oQ %q}", 42_q_m); // 52 m
fmt::print("{:%xQ %q}", 42q_m); // 2a m fmt::print("{:%xQ %q}", 42_q_m); // 2a m
fmt::print("{:%XQ %q}", 42q_m); // 2A m fmt::print("{:%XQ %q}", 42_q_m); // 2A m
The above can be printed in an alternate version thanks to the ``#`` token:: The above can be printed in an alternate version thanks to the ``#`` token::
fmt::print("{:%#bQ %q}", 42q_m); // 0b101010 m fmt::print("{:%#bQ %q}", 42_q_m); // 0b101010 m
fmt::print("{:%#BQ %q}", 42q_m); // 0B101010 m fmt::print("{:%#BQ %q}", 42_q_m); // 0B101010 m
fmt::print("{:%#oQ %q}", 42q_m); // 052 m fmt::print("{:%#oQ %q}", 42_q_m); // 052 m
fmt::print("{:%#xQ %q}", 42q_m); // 0x2a m fmt::print("{:%#xQ %q}", 42_q_m); // 0x2a m
fmt::print("{:%#XQ %q}", 42q_m); // 0X2A m fmt::print("{:%#XQ %q}", 42_q_m); // 0X2A m
For floating-point values the :token:`units-rep-type` token works as follows:: For floating-point values the :token:`units-rep-type` token works as follows::
fmt::print("{:%aQ %q}", 1.2345678q_m); // 0x9.e065152d8eae841p-3 m fmt::print("{:%aQ %q}", 1.2345678_q_m); // 0x9.e065152d8eae841p-3 m
fmt::print("{:%.3aQ %q}", 1.2345678q_m); // 0x9.e06p-3 m fmt::print("{:%.3aQ %q}", 1.2345678_q_m); // 0x9.e06p-3 m
fmt::print("{:%AQ %q}", 1.2345678q_m); // 0X9.E065152D8EAE841P-3 m fmt::print("{:%AQ %q}", 1.2345678_q_m); // 0X9.E065152D8EAE841P-3 m
fmt::print("{:%.3AQ %q}", 1.2345678q_m); // 0X9.E06P-3 m fmt::print("{:%.3AQ %q}", 1.2345678_q_m); // 0X9.E06P-3 m
fmt::print("{:%eQ %q}", 1.2345678q_m); // 1.234568e+00 m fmt::print("{:%eQ %q}", 1.2345678_q_m); // 1.234568e+00 m
fmt::print("{:%.3eQ %q}", 1.2345678q_m); // 1.235e+00 m fmt::print("{:%.3eQ %q}", 1.2345678_q_m); // 1.235e+00 m
fmt::print("{:%EQ %q}", 1.2345678q_m); // 1.234568E+00 m fmt::print("{:%EQ %q}", 1.2345678_q_m); // 1.234568E+00 m
fmt::print("{:%.3EQ %q}", 1.2345678q_m); // 1.235E+00 m fmt::print("{:%.3EQ %q}", 1.2345678_q_m); // 1.235E+00 m
fmt::print("{:%gQ %q}", 1.2345678q_m); // 1.23457 m fmt::print("{:%gQ %q}", 1.2345678_q_m); // 1.23457 m
fmt::print("{:%gQ %q}", 1.2345678e8q_m); // 1.23457e+08 m fmt::print("{:%gQ %q}", 1.2345678e8_q_m); // 1.23457e+08 m
fmt::print("{:%.3gQ %q}", 1.2345678q_m); // 1.23 m fmt::print("{:%.3gQ %q}", 1.2345678_q_m); // 1.23 m
fmt::print("{:%.3gQ %q}", 1.2345678e8q_m); // 1.23e+08 m fmt::print("{:%.3gQ %q}", 1.2345678e8_q_m); // 1.23e+08 m
fmt::print("{:%GQ %q}", 1.2345678q_m); // 1.23457 m fmt::print("{:%GQ %q}", 1.2345678_q_m); // 1.23457 m
fmt::print("{:%GQ %q}", 1.2345678e8q_m); // 1.23457E+08 m fmt::print("{:%GQ %q}", 1.2345678e8_q_m); // 1.23457E+08 m
fmt::print("{:%.3GQ %q}", 1.2345678q_m); // 1.23 m fmt::print("{:%.3GQ %q}", 1.2345678_q_m); // 1.23 m
fmt::print("{:%.3GQ %q}", 1.2345678e8q_m); // 1.23E+08 m fmt::print("{:%.3GQ %q}", 1.2345678e8_q_m); // 1.23E+08 m
Special Signs Special Signs
@ -208,7 +208,7 @@ Special Signs
Beside adding any list of regular characters as a separator between the value and the Beside adding any list of regular characters as a separator between the value and the
symbol, it is possible to type a few special signs there too:: symbol, it is possible to type a few special signs there too::
fmt::print("{:%Q_%q}", 123q_km); // 123_km fmt::print("{:%Q_%q}", 123_q_km); // 123_km
fmt::print("{:%Q%t%q}", 123q_km); // 123\tkm <tab> fmt::print("{:%Q%t%q}", 123_q_km); // 123\tkm <tab>
fmt::print("{:%Q%n%q}", 123q_km); // 123\nkm <new line> fmt::print("{:%Q%n%q}", 123_q_km); // 123\nkm <new line>
fmt::print("{:%Q%% %q}", 123q_km); // 123% km fmt::print("{:%Q%% %q}", 123_q_km); // 123% km

2
docs/framework/units.rst
View File

@ -381,7 +381,7 @@ unknown/undefined unit type like in the below example::
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
Length auto l = 100q_km_per_h * 10q_s; Length auto l = 100_q_km_per_h * 10_q_s;
The type of ``l`` above will be The type of ``l`` above will be
:expr:`si::length<scaled_unit<ratio(1, 36, 1), si::metre>, long double>`. This is caused :expr:`si::length<scaled_unit<ratio(1, 36, 1), si::metre>, long double>`. This is caused

20
docs/quick_start.rst
View File

@ -4,22 +4,22 @@ Quick Start
Here is a small example of possible operations:: Here is a small example of possible operations::
// simple numeric operations // simple numeric operations
static_assert(10q_km / 2 == 5q_km); static_assert(10_q_km / 2 == 5_q_km);
// unit conversions // unit conversions
static_assert(1q_h == 3600q_s); static_assert(1_q_h == 3600_q_s);
static_assert(1q_km + 1q_m == 1001q_m); static_assert(1_q_km + 1_q_m == 1001_q_m);
// dimension conversions // dimension conversions
static_assert(1q_km / 1q_s == 1000q_m_per_s); static_assert(1_q_km / 1_q_s == 1000_q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km); static_assert(2_q_km_per_h * 2_q_h == 4_q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h); static_assert(2_q_km / 2_q_km_per_h == 1_q_h);
static_assert(2q_m * 3q_m == 6q_m2); static_assert(2_q_m * 3_q_m == 6_q_m2);
static_assert(10q_km / 5q_km == 2); static_assert(10_q_km / 5_q_km == 2);
static_assert(1000 / 1q_s == 1q_kHz); static_assert(1000 / 1_q_s == 1_q_kHz);
.. admonition:: Try it on Compiler Explorer .. admonition:: Try it on Compiler Explorer
@ -46,7 +46,7 @@ of basic library features::
int main() int main()
{ {
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
Speed auto v1 = avg_speed(220q_km, 2q_h); Speed auto v1 = avg_speed(220_q_km, 2_q_h);
Speed auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2)); Speed auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2));
Speed auto v3 = quantity_cast<si::metre_per_second>(v2); Speed auto v3 = quantity_cast<si::metre_per_second>(v2);
Speed auto v4 = quantity_cast<int>(v3); Speed auto v4 = quantity_cast<int>(v3);

2
docs/use_cases/custom_representation_types.rst
View File

@ -90,7 +90,7 @@ representation types we have to obey similar rules::
This also applies when we want to create a quantity with a custom representation type This also applies when we want to create a quantity with a custom representation type
from a regular quantity value:: from a regular quantity value::
Length auto d = 123q_m; Length auto d = 123_q_m;
si::length<si::metre, impl> d1(d); // OK si::length<si::metre, impl> d1(d); // OK
si::length<si::metre, expl> d2(d); // Compile-time error si::length<si::metre, expl> d2(d); // Compile-time error
si::length<si::metre, expl> d3(quantity_cast<expl>(d)); // OK si::length<si::metre, expl> d3(quantity_cast<expl>(d)); // OK

2
docs/use_cases/extensions.rst
View File

@ -130,7 +130,7 @@ coherent unit::
With the above we can now check what is the production rate:: With the above we can now check what is the production rate::
DeskRate auto rate = quantity_cast<desk_per_hour>(3._d / 20q_min); DeskRate auto rate = quantity_cast<desk_per_hour>(3._d / 20_q_min);
std::cout << "Desk rate: " << rate << '\n'; // prints 'Desk rate: 9 desk/h' std::cout << "Desk rate: " << rate << '\n'; // prints 'Desk rate: 9 desk/h'
and how much wood is being consumed over a unit of time:: and how much wood is being consumed over a unit of time::

38
docs/use_cases/linear_algebra.rst
View File

@ -27,28 +27,28 @@ The official :term:`quantity` definition states:
So the most common use case would be to create a vector or matrix of quantities:: So the most common use case would be to create a vector or matrix of quantities::
fs_vector<si::length<si::metre>, 3> v = { 1q_m, 2q_m, 3q_m }; fs_vector<si::length<si::metre>, 3> v = { 1_q_m, 2_q_m, 3_q_m };
fs_vector<si::length<si::metre>, 3> u = { 3q_m, 2q_m, 1q_m }; fs_vector<si::length<si::metre>, 3> u = { 3_q_m, 2_q_m, 1_q_m };
fs_vector<si::length<si::kilometre>, 3> t = { 3q_km, 2q_km, 1q_km }; fs_vector<si::length<si::kilometre>, 3> t = { 3_q_km, 2_q_km, 1_q_km };
Having such definitions we can perform full dimensional analysis operations for the operations Having such definitions we can perform full dimensional analysis operations for the operations
allowed by the Linear Algebra rules. For example:: allowed by the Linear Algebra rules. For example::
std::cout << "v + u = " << v + u << "\n"; std::cout << "v + u = " << v + u << "\n";
std::cout << "v + t = " << v + t << "\n"; std::cout << "v + t = " << v + t << "\n";
std::cout << "t[m] = " << vector<si::length<si::metre>>(t) << "\n"; std::cout << "t[m] = " << vector<si::length<si::metre>>(t) << "\n";
std::cout << "v * u = " << v * u << "\n"; std::cout << "v * u = " << v * u << "\n";
std::cout << "2q_m * v = " << 2q_m * v << "\n"; std::cout << "2_q_m * v = " << 2_q_m * v << "\n";
The above code works as expected and produces the following output: The above code works as expected and produces the following output:
.. code-block:: text .. code-block:: text
v + u = | 4 m 4 m 4 m | v + u = | 4 m 4 m 4 m |
v + t = | 3001 m 2002 m 1003 m | v + t = | 3001 m 2002 m 1003 m |
t[m] = | 3000 m 2000 m 1000 m | t[m] = | 3000 m 2000 m 1000 m |
v * u = 10 m² v * u = 10 m²
2q_m * v = | 2 m² 4 m² 6 m² | 2_q_m * v = | 2 m² 4 m² 6 m² |
Quantities of Linear Algebra Types Quantities of Linear Algebra Types
@ -74,14 +74,14 @@ output:
.. code-block:: text .. code-block:: text
v + u = | 4 4 4 | m v + u = | 4 4 4 | m
v + t = | 3001 2002 1003 | m v + t = | 3001 2002 1003 | m
t[m] = | 3000 2000 1000 | m t[m] = | 3000 2000 1000 | m
v * u = 10 m² v * u = 10 m²
2q_m * v = | 2 4 6 | m² 2_q_m * v = | 2 4 6 | m²
.. seealso:: .. seealso::
For more examples of Linear Algebra definition and operations please refer to For more examples of Linear Algebra definition and operations please refer to
the :ref:`linear_algebra` example. the :ref:`linear_algebra` example.

10
docs/use_cases/unknown_dimensions.rst
View File

@ -26,7 +26,7 @@ will determine its type. The same applies to the resulting unit. For example:
using namespace units::physical::si; using namespace units::physical::si;
constexpr auto result = 144q_km / 2q_h; constexpr auto result = 144_q_km / 2_q_h;
static_assert(is_same_v<decltype(result)::dimension, dim_speed>); static_assert(is_same_v<decltype(result)::dimension, dim_speed>);
static_assert(is_same_v<decltype(result)::unit, kilometre_per_hour>); static_assert(is_same_v<decltype(result)::unit, kilometre_per_hour>);
@ -44,7 +44,7 @@ we forget to include a header file with the resulting dimension definition:
using namespace units::physical::si; using namespace units::physical::si;
constexpr auto result = 144q_km / 2q_h; constexpr auto result = 144_q_km / 2_q_h;
static_assert(is_same_v<decltype(result)::dimension, static_assert(is_same_v<decltype(result)::dimension,
unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, -1>>>); unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, -1>>>);
static_assert(is_same_v<decltype(result)::unit, static_assert(is_same_v<decltype(result)::unit,
@ -96,10 +96,10 @@ in your program. A typical example here are temporary results of a long calculat
{ {
Speed auto s1 = avg_speed(d, t); Speed auto s1 = avg_speed(d, t);
auto temp1 = s1 * 200q_km; // intermediate unknown dimension auto temp1 = s1 * 200_q_km; // intermediate unknown dimension
Speed auto s2 = temp1 / 50q_km; // back to known dimensions again Speed auto s2 = temp1 / 50_q_km; // back to known dimensions again
Length auto d2 = s2 * 4q_h; Length auto d2 = s2 * 4_q_h;
// ... // ...
} }

8
example/alternative_namespaces/box_example.cpp
View File

@ -56,11 +56,11 @@ using namespace units::physical::si::literals;
int main() int main()
{ {
auto box = Box{1000.0q_mm, 500.0q_mm, 200.0q_mm}; auto box = Box{1000.0_q_mm, 500.0_q_mm, 200.0_q_mm};
box.set_contents_density(1000.0q_kg_per_m3); box.set_contents_density(1000.0_q_kg_per_m3);
auto fill_time = 200.0q_s; // time since starting fill auto fill_time = 200.0_q_s; // time since starting fill
auto measured_mass = 20.0q_kg; // measured mass at fill_time auto measured_mass = 20.0_q_kg; // measured mass at fill_time
std::cout << "mpusz/units box example ( using experimental alternative syntax for defining quantities) ...\n"; std::cout << "mpusz/units box example ( using experimental alternative syntax for defining quantities) ...\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/alternative_namespaces/capacitor_time_curve.cpp
View File

@ -36,22 +36,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.47q_uF; constexpr auto C = 0.47_q_uF;
constexpr auto V0 = 5.0q_V; constexpr auto V0 = 5.0_q_V;
constexpr auto R = 4.7q_kR; constexpr auto R = 4.7_q_kR;
for (auto t = 0q_ms; t <= 50q_ms; ++t) { for (auto t = 0_q_ms; t <= 50_q_ms; ++t) {
const auto Vt = V0 * units::exp(-t / (R * C)); const auto Vt = V0 * units::exp(-t / (R * C));
std::cout << "at " << t << " voltage is "; std::cout << "at " << t << " voltage is ";
if (Vt >= 1q_V) if (Vt >= 1_q_V)
std::cout << Vt; std::cout << Vt;
else if (Vt >= 1q_mV) else if (Vt >= 1_q_mV)
std::cout << voltage::mV<>{Vt}; std::cout << voltage::mV<>{Vt};
else if (Vt >= 1q_uV) else if (Vt >= 1_q_uV)
std::cout << voltage::uV<>{Vt}; std::cout << voltage::uV<>{Vt};
else if (Vt >= 1q_nV) else if (Vt >= 1_q_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/alternative_namespaces/clcpp_response.cpp
View File

@ -33,12 +33,12 @@ void simple_quantities()
using distance = length::m<>; using distance = length::m<>;
using q_time = q_time::s<>; using q_time = q_time::s<>;
constexpr distance km = 1.0q_km; constexpr distance km = 1.0_q_km;
constexpr distance miles = 1.0q_mi; constexpr distance miles = 1.0_q_mi;
constexpr q_time sec = 1q_s; constexpr q_time sec = 1_q_s;
constexpr q_time min = 1q_min; constexpr q_time min = 1_q_min;
constexpr q_time hr = 1q_h; constexpr q_time hr = 1_q_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";
@ -51,12 +51,12 @@ void simple_quantities()
void quantities_with_typed_units() void quantities_with_typed_units()
{ {
constexpr length::km<> km = 1.0q_km; constexpr length::km<> km = 1.0_q_km;
constexpr length::mi<> miles = 1.0q_mi; constexpr length::mi<> miles = 1.0_q_mi;
constexpr q_time::s<> sec = 1q_s; constexpr q_time::s<> sec = 1_q_s;
constexpr q_time::min<> min = 1q_min; constexpr q_time::min<> min = 1_q_min;
constexpr q_time::h<> hr = 1q_h; constexpr q_time::h<> hr = 1_q_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';
@ -65,7 +65,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 = 1q_m; constexpr length::m<> meter = 1_q_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";
@ -97,8 +97,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 = 2.q_fm; length::fm<float> L1A = 2._q_fm;
length::fm<float> L2A = 3.q_fm; length::fm<float> L2A = 3._q_fm;
length::fm<float> LrA = L1A + L2A; length::fm<float> LrA = L1A + L2A;
fmt::print("{:%.30Q %q}\n + {:%.30Q %q}\n = {:%.30Q %q}\n\n",L1A,L2A,LrA); fmt::print("{:%.30Q %q}\n + {:%.30Q %q}\n = {:%.30Q %q}\n\n",L1A,L2A,LrA);

2
example/alternative_namespaces/conversion_factor.cpp
View File

@ -47,7 +47,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.0q_m; constexpr length::m<> lengthA = 2.0_q_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/alternative_namespaces/timer.cpp
View File

@ -13,7 +13,7 @@ int main()
{ {
std::cout << "Simple timer using mpusz/units ...\n"; std::cout << "Simple timer using mpusz/units ...\n";
auto const period = 0.5q_s; auto const period = 0.5_q_s;
auto const duration = 10 * period; auto const duration = 10 * period;
timer t; timer t;

16
example/avg_speed.cpp
View File

@ -68,7 +68,7 @@ void example()
// SI (int) // SI (int)
{ {
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
constexpr Length auto distance = 220q_km; // constructed from a UDL constexpr Length auto distance = 220_q_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,7 +82,7 @@ void example()
// SI (double) // SI (double)
{ {
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
constexpr Length auto distance = 220.q_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::physical::international::literals; using namespace units::physical::international::literals;
constexpr Length auto distance = 140q_mi; // constructed from a UDL constexpr Length auto distance = 140_q_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,8 +114,8 @@ void example()
// Customary Units (double) // Customary Units (double)
{ {
using namespace units::physical::international::literals; using namespace units::physical::international::literals;
constexpr Length auto distance = 140.q_mi; // constructed from a UDL constexpr Length auto distance = 140._q_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,7 +132,7 @@ void example()
// CGS (int) // CGS (int)
{ {
using namespace units::physical::cgs::literals; using namespace units::physical::cgs::literals;
constexpr Length auto distance = 22'000'000q_cm; // constructed from a UDL constexpr Length auto distance = 22'000'000_q_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::physical::cgs::literals; using namespace units::physical::cgs::literals;
constexpr Length auto distance = 22'000'000.q_cm; // constructed from a UDL constexpr Length auto distance = 22'000'000._q_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";

10
example/box_example.cpp
View File

@ -25,7 +25,7 @@ inline constexpr auto g = si::si2019::standard_gravity<>;
} // namespace } // namespace
struct Box { struct Box {
static constexpr auto air_density = 1.225q_kg_per_m3; static constexpr auto air_density = 1.225_q_kg_per_m3;
si::length<m> length; si::length<m> length;
si::length<m> width; si::length<m> width;
@ -65,11 +65,11 @@ struct Box {
int main() int main()
{ {
auto box = Box(1000.0q_mm, 500.0q_mm, 200.0q_mm); auto box = Box(1000.0_q_mm, 500.0_q_mm, 200.0_q_mm);
box.set_contents_density(1000.0q_kg_per_m3); box.set_contents_density(1000.0_q_kg_per_m3);
const auto fill_time = 200.0q_s; // time since starting fill const auto fill_time = 200.0_q_s; // time since starting fill
const auto measured_mass = 20.0q_kg; // measured mass at fill_time const auto measured_mass = 20.0_q_kg; // measured mass at fill_time
std::cout << "mp-units box example...\n"; std::cout << "mp-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

@ -36,22 +36,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.47q_uF; constexpr auto C = 0.47_q_uF;
constexpr auto V0 = 5.0q_V; constexpr auto V0 = 5.0_q_V;
constexpr auto R = 4.7q_kR; constexpr auto R = 4.7_q_kR;
for (auto t = 0q_ms; t <= 50q_ms; ++t) { for (auto t = 0_q_ms; t <= 50_q_ms; ++t) {
const Voltage auto Vt = V0 * units::exp(-t / (R * C)); const Voltage auto Vt = V0 * units::exp(-t / (R * C));
std::cout << "at " << t << " voltage is "; std::cout << "at " << t << " voltage is ";
if (Vt >= 1q_V) if (Vt >= 1_q_V)
std::cout << Vt; std::cout << Vt;
else if (Vt >= 1q_mV) else if (Vt >= 1_q_mV)
std::cout << quantity_cast<millivolt>(Vt); std::cout << quantity_cast<millivolt>(Vt);
else if (Vt >= 1q_uV) else if (Vt >= 1_q_uV)
std::cout << quantity_cast<microvolt>(Vt); std::cout << quantity_cast<microvolt>(Vt);
else if (Vt >= 1q_nV) else if (Vt >= 1_q_nV)
std::cout << quantity_cast<nanovolt>(Vt); std::cout << quantity_cast<nanovolt>(Vt);
else else
std::cout << quantity_cast<picovolt>(Vt); std::cout << quantity_cast<picovolt>(Vt);

26
example/clcpp_response.cpp
View File

@ -39,12 +39,12 @@ void simple_quantities()
using distance = length<metre>; using distance = length<metre>;
using duration = physical::si::time<second>; using duration = physical::si::time<second>;
constexpr distance km = 1.0q_km; constexpr distance km = 1.0_q_km;
constexpr distance miles = 1.0q_mi; constexpr distance miles = 1.0_q_mi;
constexpr duration sec = 1q_s; constexpr duration sec = 1_q_s;
constexpr duration min = 1q_min; constexpr duration min = 1_q_min;
constexpr duration hr = 1q_h; constexpr duration hr = 1_q_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";
@ -61,14 +61,14 @@ void quantities_with_typed_units()
using namespace units::physical::si; using namespace units::physical::si;
using namespace units::physical::international; using namespace units::physical::international;
constexpr length<kilometre> km = 1.0q_km; constexpr length<kilometre> km = 1.0_q_km;
constexpr length<mile> miles = 1.0q_mi; constexpr length<mile> miles = 1.0_q_mi;
std::cout.precision(6); std::cout.precision(6);
constexpr si::time<second> sec = 1q_s; constexpr si::time<second> sec = 1_q_s;
constexpr si::time<minute> min = 1q_min; constexpr si::time<minute> min = 1_q_min;
constexpr si::time<hour> hr = 1q_h; constexpr si::time<hour> hr = 1_q_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';
@ -77,7 +77,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<metre> meter = 1q_m; constexpr length<metre> meter = 1_q_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";
@ -111,8 +111,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<femtometre,float> L1A = 2.q_fm; length<femtometre,float> L1A = 2._q_fm;
length<femtometre,float> L2A = 3.q_fm; length<femtometre,float> L2A = 3._q_fm;
length<femtometre,float> LrA = L1A + L2A; length<femtometre,float> LrA = L1A + L2A;
fmt::print("{:%.30Q %q}\n + {:%.30Q %q}\n = {:%.30Q %q}\n\n",L1A,L2A,LrA); fmt::print("{:%.30Q %q}\n + {:%.30Q %q}\n = {:%.30Q %q}\n\n",L1A,L2A,LrA);

2
example/conversion_factor.cpp
View File

@ -45,7 +45,7 @@ int main()
std::cout << "conversion factor in mp-units...\n\n"; std::cout << "conversion factor in mp-units...\n\n";
constexpr length<metre> lengthA = 2.0q_m; constexpr length<metre> lengthA = 2.0_q_m;
constexpr length<millimetre> lengthB = lengthA; constexpr length<millimetre> lengthB = lengthA;
std::cout << fmt::format("lengthA( {} ) and lengthB( {} )\n", lengthA, lengthB) std::cout << fmt::format("lengthA( {} ) and lengthB( {} )\n", lengthA, lengthB)

4
example/experimental_angle.cpp
View File

@ -31,8 +31,8 @@ using namespace units::physical::si::literals;
int main() int main()
{ {
auto torque = 20.0q_Nm; auto torque = 20.0_q_Nm;
auto energy = 20.0q_J; auto energy = 20.0_q_J;
physical::Angle auto angle = torque / energy; physical::Angle auto angle = torque / energy;

8
example/foot_pound_second.cpp
View File

@ -67,7 +67,7 @@ auto fmt_line(const Q a)
void print_details(std::string_view description, const Ship& ship) void print_details(std::string_view description, const Ship& ship)
{ {
using namespace units::physical::fps::literals; using namespace units::physical::fps::literals;
const auto waterDensity = 62.4q_lb_per_ft3; const auto waterDensity = 62.4_q_lb_per_ft3;
std::cout << fmt::format("{}\n", description); std::cout << fmt::format("{}\n", description);
std::cout << fmt::format("{:20} : {}\n", "length", fmt_line<fps::length<fps::yard>, si::length<si::metre>>(ship.length)) std::cout << fmt::format("{:20} : {}\n", "length", fmt_line<fps::length<fps::yard>, si::length<si::metre>>(ship.length))
<< fmt::format("{:20} : {}\n", "draft", fmt_line<fps::length<fps::yard>, si::length<si::metre>>(ship.draft)) << fmt::format("{:20} : {}\n", "draft", fmt_line<fps::length<fps::yard>, si::length<si::metre>>(ship.draft))
@ -87,13 +87,13 @@ int main()
using namespace units::physical::fps::literals; using namespace units::physical::fps::literals;
// KMS Bismark, using the units the Germans would use, taken from Wiki // KMS Bismark, using the units the Germans would use, taken from Wiki
auto bismark = Ship{.length{251.q_m}, .draft{9.3q_m}, .beam{36q_m}, .speed{56q_km_per_h}, .mass{50'300q_t}, .mainGuns{380q_mm}, .shellMass{800q_kg}, .shellSpeed{820.q_m_per_s}, .power{110.45q_kW}}; auto bismark = Ship{.length{251._q_m}, .draft{9.3_q_m}, .beam{36_q_m}, .speed{56_q_km_per_h}, .mass{50'300_q_t}, .mainGuns{380_q_mm}, .shellMass{800_q_kg}, .shellSpeed{820._q_m_per_s}, .power{110.45_q_kW}};
// USS Iowa, using units from the foot-pound-second system // USS Iowa, using units from the foot-pound-second system
auto iowa = Ship{.length{860.q_ft}, .draft{37.q_ft + 2.q_in}, .beam{108.q_ft + 2.q_in}, .speed{33q_knot}, .mass{57'540q_lton}, .mainGuns{16q_in}, .shellMass{2700q_lb}, .shellSpeed{2690.q_ft_per_s}, .power{212'000q_hp}}; auto iowa = Ship{.length{860._q_ft}, .draft{37._q_ft + 2._q_in}, .beam{108._q_ft + 2._q_in}, .speed{33_q_knot}, .mass{57'540_q_lton}, .mainGuns{16_q_in}, .shellMass{2700_q_lb}, .shellSpeed{2690._q_ft_per_s}, .power{212'000_q_hp}};
// HMS King George V, using units from the foot-pound-second system // HMS King George V, using units from the foot-pound-second system
auto kgv = Ship{.length{745.1q_ft}, .draft{33.q_ft + 7.5q_in}, .beam{103.2q_ft + 2.5q_in}, .speed{28.3q_knot}, .mass{42'245q_lton}, .mainGuns{14q_in}, .shellMass{1'590q_lb}, .shellSpeed{2483.q_ft_per_s}, .power{110'000q_hp}}; auto kgv = Ship{.length{745.1_q_ft}, .draft{33._q_ft + 7.5_q_in}, .beam{103.2_q_ft + 2.5_q_in}, .speed{28.3_q_knot}, .mass{42'245_q_lton}, .mainGuns{14_q_in}, .shellMass{1'590_q_lb}, .shellSpeed{2483._q_ft_per_s}, .power{110'000_q_hp}};
print_details("KMS Bismark, defined in appropriate units from the SI system", bismark); print_details("KMS Bismark, defined in appropriate units from the SI system", bismark);
std::cout << "\n\n"; std::cout << "\n\n";

26
example/glide_computer.cpp
View File

@ -217,10 +217,10 @@ struct glider {
auto get_gliders() auto get_gliders()
{ {
const std::array gliders = { const std::array gliders = {
glider{"SZD-30 Pirat", {velocity(83q_km_per_h), rate_of_climb(-0.7389q_m_per_s)}}, glider{"SZD-30 Pirat", {velocity(83_q_km_per_h), rate_of_climb(-0.7389_q_m_per_s)}},
glider{"SZD-51 Junior", {velocity(80q_km_per_h), rate_of_climb(-0.6349q_m_per_s)}}, glider{"SZD-51 Junior", {velocity(80_q_km_per_h), rate_of_climb(-0.6349_q_m_per_s)}},
glider{"SZD-48 Jantar Std 3", {velocity(110q_km_per_h), rate_of_climb(-0.77355q_m_per_s)}}, glider{"SZD-48 Jantar Std 3", {velocity(110_q_km_per_h), rate_of_climb(-0.77355_q_m_per_s)}},
glider{"SZD-56 Diana", {velocity(110q_km_per_h), rate_of_climb(-0.63657q_m_per_s)}} glider{"SZD-56 Diana", {velocity(110_q_km_per_h), rate_of_climb(-0.63657_q_m_per_s)}}
}; };
return gliders; return gliders;
} }
@ -258,9 +258,9 @@ struct weather {
auto get_weather_conditions() auto get_weather_conditions()
{ {
const std::array weather_conditions = { const std::array weather_conditions = {
std::pair("Good", weather{height(1900q_m), rate_of_climb(4.3q_m_per_s)}), std::pair("Good", weather{height(1900_q_m), rate_of_climb(4.3_q_m_per_s)}),
std::pair("Medium", weather{height(1550q_m), rate_of_climb(2.8q_m_per_s)}), std::pair("Medium", weather{height(1550_q_m), rate_of_climb(2.8_q_m_per_s)}),
std::pair("Bad", weather{height(850q_m), rate_of_climb(1.8q_m_per_s)}) std::pair("Bad", weather{height(850_q_m), rate_of_climb(1.8_q_m_per_s)})
}; };
return weather_conditions; return weather_conditions;
} }
@ -462,7 +462,7 @@ void estimate(const glider& g, const weather& w, const task& t, const safety& s,
// circle in a thermall to gain height // circle in a thermall to gain height
point = circle(point, g, w, t, height_to_gain); point = circle(point, g, w, t, height_to_gain);
} }
while(height_to_gain > height(0q_m)); while(height_to_gain > height(0_q_m));
// final glide // final glide
point = final_glide(point, g, t); point = final_glide(point, g, t);
@ -482,16 +482,16 @@ void example()
print(weather_conditions); print(weather_conditions);
const task t = { const task t = {
waypoint{"EPPR", altitude(16q_ft)}, waypoint{"EPPR", altitude(16_q_ft)},
waypoint{"EPGI", altitude(115q_ft)}, waypoint{"EPGI", altitude(115_q_ft)},
distance(81.7q_km) distance(81.7_q_km)
}; };
print(t); print(t);
const safety s = {height(300q_m)}; const safety s = {height(300_q_m)};
print(s); print(s);
const aircraft_tow tow = {height(400q_m), rate_of_climb(1.6q_m_per_s)}; const aircraft_tow tow = {height(400_q_m), rate_of_climb(1.6_q_m_per_s)};
print(tow); print(tow);
for(const auto& g : gliders) { for(const auto& g : gliders) {

2
example/hello_units.cpp
View File

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

12
example/kalman_filter-alpha_beta_filter_example2.cpp
View File

@ -21,7 +21,7 @@ struct state_variable {
using namespace units::physical; using namespace units::physical;
using namespace units::physical::si::literals; using namespace units::physical::si::literals;
constexpr auto radar_transmit_interval = 5.0q_s; constexpr auto radar_transmit_interval = 5.0_q_s;
constexpr double kalman_range_gain = 0.2; constexpr double kalman_range_gain = 0.2;
constexpr double kalman_speed_gain = 0.1; constexpr double kalman_speed_gain = 0.1;
@ -52,16 +52,16 @@ int main()
std::cout << "\n\n1d aircraft α-β filter example2 from https://www.kalmanfilter.net/alphabeta.html#ex2"; std::cout << "\n\n1d aircraft α-β filter example2 from https://www.kalmanfilter.net/alphabeta.html#ex2";
std::cout << "\n\n"; std::cout << "\n\n";
constexpr auto measurements = std::array{0.0q_m, // N.B measurement[0] is unknown and unused constexpr auto measurements = std::array{0.0_q_m, // N.B measurement[0] is unknown and unused
30110.0q_m, 30265.0q_m, 30740.0q_m, 30750.0q_m, 31135.0q_m, 30110.0_q_m, 30265.0_q_m, 30740.0_q_m, 30750.0_q_m, 31135.0_q_m,
31015.0q_m, 31180.0q_m, 31610.0q_m, 31960.0q_m, 31865.0q_m}; 31015.0_q_m, 31180.0_q_m, 31610.0_q_m, 31960.0_q_m, 31865.0_q_m};
constexpr auto num_measurements = measurements.size(); constexpr auto num_measurements = measurements.size();
std::array<state,num_measurements> track; std::array<state,num_measurements> track;
// We need an initial estimate of track[0] as there is no previous state to get a prediction from // We need an initial estimate of track[0] as there is no previous state to get a prediction from
track[0].range.estimated_current_state = 30'000q_m; track[0].range.estimated_current_state = 30'000_q_m;
track[0].speed.estimated_current_state = 40.0q_m_per_s; track[0].speed.estimated_current_state = 40.0_q_m_per_s;
for (auto n = 0U; n < num_measurements; ++n) { for (auto n = 0U; n < num_measurements; ++n) {
if (n > 0) { if (n > 0) {

56
example/linear_algebra.cpp
View File

@ -68,9 +68,9 @@ void vector_of_quantity_add()
{ {
std::cout << "\nvector_of_quantity_add:\n"; std::cout << "\nvector_of_quantity_add:\n";
vector<si::length<si::metre>> v = { 1q_m, 2q_m, 3q_m }; vector<si::length<si::metre>> v = { 1_q_m, 2_q_m, 3_q_m };
vector<si::length<si::metre>> u = { 3q_m, 2q_m, 1q_m }; vector<si::length<si::metre>> u = { 3_q_m, 2_q_m, 1_q_m };
vector<si::length<si::kilometre>> t = { 3q_km, 2q_km, 1q_km }; vector<si::length<si::kilometre>> t = { 3_q_km, 2_q_km, 1_q_km };
std::cout << "v = " << v << "\n"; std::cout << "v = " << v << "\n";
std::cout << "u = " << u << "\n"; std::cout << "u = " << u << "\n";
@ -85,28 +85,28 @@ void vector_of_quantity_multiply_same()
{ {
std::cout << "\nvector_of_quantity_multiply_same:\n"; std::cout << "\nvector_of_quantity_multiply_same:\n";
vector<si::length<si::metre>> v = { 1q_m, 2q_m, 3q_m }; vector<si::length<si::metre>> v = { 1_q_m, 2_q_m, 3_q_m };
vector<si::length<si::metre>> u = { 3q_m, 2q_m, 1q_m }; vector<si::length<si::metre>> u = { 3_q_m, 2_q_m, 1_q_m };
std::cout << "v = " << v << "\n"; std::cout << "v = " << v << "\n";
std::cout << "u = " << u << "\n"; std::cout << "u = " << u << "\n";
std::cout << "v * u = " << v * u << "\n"; std::cout << "v * u = " << v * u << "\n";
std::cout << "2q_m * v = " << 2.q_m * v << "\n"; std::cout << "2_q_m * v = " << 2._q_m * v << "\n";
} }
void vector_of_quantity_multiply_different() void vector_of_quantity_multiply_different()
{ {
std::cout << "\nvector_of_quantity_multiply_different:\n"; std::cout << "\nvector_of_quantity_multiply_different:\n";
vector<si::force<si::newton>> v = { 1q_N, 2q_N, 3q_N }; vector<si::force<si::newton>> v = { 1_q_N, 2_q_N, 3_q_N };
vector<si::length<si::metre>> u = { 3q_m, 2q_m, 1q_m }; vector<si::length<si::metre>> u = { 3_q_m, 2_q_m, 1_q_m };
std::cout << "v = " << v << "\n"; std::cout << "v = " << v << "\n";
std::cout << "u = " << u << "\n"; std::cout << "u = " << u << "\n";
std::cout << "v * u = " << v * u << "\n"; std::cout << "v * u = " << v * u << "\n";
std::cout << "2q_N * u = " << 2.q_N * u << "\n"; std::cout << "2_q_N * u = " << 2._q_N * u << "\n";
std::cout << "2 * u = " << 2 * u << "\n"; std::cout << "2 * u = " << 2 * u << "\n";
} }
@ -114,12 +114,12 @@ void vector_of_quantity_divide_by_scalar()
{ {
std::cout << "\nvector_of_quantity_divide_by_scalar:\n"; std::cout << "\nvector_of_quantity_divide_by_scalar:\n";
vector<si::length<si::metre>> v = { 4q_m, 8q_m, 12q_m }; vector<si::length<si::metre>> v = { 4_q_m, 8_q_m, 12_q_m };
std::cout << "v = " << v << "\n"; std::cout << "v = " << v << "\n";
// TODO Uncomment when bug in the LA is fixed // TODO Uncomment when bug in the LA is fixed
// std::cout << "v / 2q_s = " << v / 2q_s << "\n"; // std::cout << "v / 2_q_s = " << v / 2_q_s << "\n";
// std::cout << "v / 2 = " << v / 2 << "\n"; // std::cout << "v / 2 = " << v / 2 << "\n";
} }
@ -135,9 +135,9 @@ void matrix_of_quantity_add()
{ {
std::cout << "\nmatrix_of_quantity_add:\n"; std::cout << "\nmatrix_of_quantity_add:\n";
matrix<si::length<si::metre>> v = {{ 1q_m, 2q_m, 3q_m }, { 4q_m, 5q_m, 6q_m }, { 7q_m, 8q_m, 9q_m }}; matrix<si::length<si::metre>> v = {{ 1_q_m, 2_q_m, 3_q_m }, { 4_q_m, 5_q_m, 6_q_m }, { 7_q_m, 8_q_m, 9_q_m }};
matrix<si::length<si::metre>> u = {{ 3q_m, 2q_m, 1q_m }, { 3q_m, 2q_m, 1q_m }, { 3q_m, 2q_m, 1q_m }}; matrix<si::length<si::metre>> u = {{ 3_q_m, 2_q_m, 1_q_m }, { 3_q_m, 2_q_m, 1_q_m }, { 3_q_m, 2_q_m, 1_q_m }};
matrix<si::length<si::millimetre>> t = {{ 3q_mm, 2q_mm, 1q_mm }, { 3q_mm, 2q_mm, 1q_mm }, { 3q_mm, 2q_mm, 1q_mm }}; matrix<si::length<si::millimetre>> t = {{ 3_q_mm, 2_q_mm, 1_q_mm }, { 3_q_mm, 2_q_mm, 1_q_mm }, { 3_q_mm, 2_q_mm, 1_q_mm }};
std::cout << "v =\n" << v << "\n"; std::cout << "v =\n" << v << "\n";
std::cout << "u =\n" << u << "\n"; std::cout << "u =\n" << u << "\n";
@ -154,28 +154,28 @@ void matrix_of_quantity_multiply_same()
{ {
std::cout << "\nmatrix_of_quantity_multiply_same:\n"; std::cout << "\nmatrix_of_quantity_multiply_same:\n";
matrix<si::length<si::metre>> v = {{ 1q_m, 2q_m, 3q_m }, { 4q_m, 5q_m, 6q_m }, { 7q_m, 8q_m, 9q_m }}; matrix<si::length<si::metre>> v = {{ 1_q_m, 2_q_m, 3_q_m }, { 4_q_m, 5_q_m, 6_q_m }, { 7_q_m, 8_q_m, 9_q_m }};
vector<si::length<si::metre>> u = { 3q_m, 2q_m, 1q_m }; vector<si::length<si::metre>> u = { 3_q_m, 2_q_m, 1_q_m };
std::cout << "v =\n" << v << "\n"; std::cout << "v =\n" << v << "\n";
std::cout << "u =\n" << u << "\n"; std::cout << "u =\n" << u << "\n";
std::cout << "v * u =\n" << v * u << "\n"; std::cout << "v * u =\n" << v * u << "\n";
std::cout << "2q_m * u =\n" << 2.q_m * u << "\n"; std::cout << "2_q_m * u =\n" << 2._q_m * u << "\n";
} }
void matrix_of_quantity_multiply_different() void matrix_of_quantity_multiply_different()
{ {
std::cout << "\nmatrix_of_quantity_multiply_different:\n"; std::cout << "\nmatrix_of_quantity_multiply_different:\n";
vector<si::force<si::newton>> v = { 1q_N, 2q_N, 3q_N }; vector<si::force<si::newton>> v = { 1_q_N, 2_q_N, 3_q_N };
matrix<si::length<si::metre>> u = {{ 1q_m, 2q_m, 3q_m }, { 4q_m, 5q_m, 6q_m }, { 7q_m, 8q_m, 9q_m }}; matrix<si::length<si::metre>> u = {{ 1_q_m, 2_q_m, 3_q_m }, { 4_q_m, 5_q_m, 6_q_m }, { 7_q_m, 8_q_m, 9_q_m }};
std::cout << "v =\n" << v << "\n"; std::cout << "v =\n" << v << "\n";
std::cout << "u =\n" << u << "\n"; std::cout << "u =\n" << u << "\n";
std::cout << "v * u =\n" << v * u << "\n"; std::cout << "v * u =\n" << v * u << "\n";
std::cout << "2q_N * u =\n" << 2.q_N * u << "\n"; std::cout << "2_q_N * u =\n" << 2._q_N * u << "\n";
std::cout << "2 * u =\n" << 2 * u << "\n"; std::cout << "2 * u =\n" << 2 * u << "\n";
} }
@ -183,12 +183,12 @@ void matrix_of_quantity_divide_by_scalar()
{ {
std::cout << "\nmatrix_of_quantity_divide_by_scalar:\n"; std::cout << "\nmatrix_of_quantity_divide_by_scalar:\n";
matrix<si::length<si::metre>> v = {{ 2q_m, 4q_m, 6q_m }, { 4q_m, 6q_m, 8q_m }, { 8q_m, 4q_m, 2q_m }}; matrix<si::length<si::metre>> v = {{ 2_q_m, 4_q_m, 6_q_m }, { 4_q_m, 6_q_m, 8_q_m }, { 8_q_m, 4_q_m, 2_q_m }};
std::cout << "v =\n" << v << "\n"; std::cout << "v =\n" << v << "\n";
// TODO Uncomment when bug in the LA is fixed // TODO Uncomment when bug in the LA is fixed
// std::cout << "v / 2q_s =\n" << v / 2q_s << "\n"; // std::cout << "v / 2_q_s =\n" << v / 2_q_s << "\n";
// std::cout << "v / 2 =\n" << v / 2 << "\n"; // std::cout << "v / 2 =\n" << v / 2 << "\n";
} }
@ -234,7 +234,7 @@ void quantity_of_vector_multiply_same()
std::cout << "u = " << u << "\n"; std::cout << "u = " << u << "\n";
std::cout << "v * u = " << v * u << "\n"; std::cout << "v * u = " << v * u << "\n";
std::cout << "2q_m * v = " << 2.q_m * v << "\n"; std::cout << "2_q_m * v = " << 2._q_m * v << "\n";
} }
void quantity_of_vector_multiply_different() void quantity_of_vector_multiply_different()
@ -248,7 +248,7 @@ void quantity_of_vector_multiply_different()
std::cout << "u = " << u << "\n"; std::cout << "u = " << u << "\n";
std::cout << "v * u = " << v * u << "\n"; std::cout << "v * u = " << v * u << "\n";
std::cout << "2q_N * u = " << 2.q_N * u << "\n"; std::cout << "2_q_N * u = " << 2._q_N * u << "\n";
std::cout << "2 * u = " << 2 * u << "\n"; std::cout << "2 * u = " << 2 * u << "\n";
} }
@ -261,7 +261,7 @@ void quantity_of_vector_divide_by_scalar()
std::cout << "v = " << v << "\n"; std::cout << "v = " << v << "\n";
// TODO Uncomment when bug in the LA is fixed // TODO Uncomment when bug in the LA is fixed
// std::cout << "v / 2q_s = " << v / 2q_s << "\n"; // std::cout << "v / 2_q_s = " << v / 2_q_s << "\n";
// std::cout << "v / 2 = " << v / 2 << "\n"; // std::cout << "v / 2 = " << v / 2 << "\n";
} }
@ -306,7 +306,7 @@ void quantity_of_matrix_multiply_same()
std::cout << "u =\n" << u << "\n"; std::cout << "u =\n" << u << "\n";
std::cout << "v * u =\n" << v * u << "\n"; std::cout << "v * u =\n" << v * u << "\n";
std::cout << "2q_m * u =\n" << 2.q_m * u << "\n"; std::cout << "2_q_m * u =\n" << 2._q_m * u << "\n";
} }
void quantity_of_matrix_multiply_different() void quantity_of_matrix_multiply_different()
@ -320,7 +320,7 @@ void quantity_of_matrix_multiply_different()
std::cout << "u =\n" << u << "\n"; std::cout << "u =\n" << u << "\n";
std::cout << "v * u =\n" << v * u << "\n"; std::cout << "v * u =\n" << v * u << "\n";
std::cout << "2q_N * u =\n" << 2.q_N * u << "\n"; std::cout << "2_q_N * u =\n" << 2._q_N * u << "\n";
std::cout << "2 * u =\n" << 2 * u << "\n"; std::cout << "2 * u =\n" << 2 * u << "\n";
} }
@ -333,7 +333,7 @@ void quantity_of_matrix_divide_by_scalar()
std::cout << "v =\n" << v << "\n"; std::cout << "v =\n" << v << "\n";
// TODO Uncomment when bug in the LA is fixed // TODO Uncomment when bug in the LA is fixed
// std::cout << "v / 2q_s =\n" << v / 2q_s << "\n"; // std::cout << "v / 2_q_s =\n" << v / 2_q_s << "\n";
// std::cout << "v / 2 =\n" << v / 2 << "\n"; // std::cout << "v / 2 =\n" << v / 2 << "\n";
} }

4
example/total_energy.cpp
View File

@ -46,8 +46,8 @@ void si_example()
std::cout << "\n*** SI units (c = " << c << ") ***\n"; std::cout << "\n*** SI units (c = " << c << ") ***\n";
const Momentum auto p = 4.q_GeV / c; const Momentum auto p = 4._q_GeV / c;
const Mass auto m = 3.q_GeV / pow<2>(c); const Mass auto m = 3._q_GeV / pow<2>(c);
const Energy auto E = total_energy(p, m, c); const Energy auto E = total_energy(p, m, c);
std::cout << "[in GeV]\n" std::cout << "[in GeV]\n"

10
example/unknown_dimension.cpp
View File

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

2
src/CMakeLists.txt
View File

@ -71,14 +71,12 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_compile_options(mp-units target_compile_options(mp-units
INTERFACE INTERFACE
-Wno-literal-suffix
-Wno-non-template-friend -Wno-non-template-friend
) )
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_compile_options(mp-units target_compile_options(mp-units
INTERFACE INTERFACE
/utf-8 # Specifies both the source character set and the execution character set as UTF-8 /utf-8 # Specifies both the source character set and the execution character set as UTF-8
/wd4455 # 'operator name': literal suffix identifiers that do not start with an underscore are reserved
) )
endif() endif()

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"" q_b_per_s(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_b_per_s(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); }
constexpr auto operator"" q_Kib_per_s(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_Kib_per_s(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); }
constexpr auto operator"" q_Mib_per_s(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_Mib_per_s(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); }
constexpr auto operator"" q_Gib_per_s(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_Gib_per_s(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); }
constexpr auto operator"" q_Tib_per_s(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_Tib_per_s(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); }
constexpr auto operator"" q_Pib_per_s(unsigned long long l) { return bitrate<pebibit_per_second, std::int64_t>(l); } constexpr auto operator"" _q_Pib_per_s(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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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/format.h
View File

@ -437,7 +437,7 @@ public:
fmt::detail::handle_dynamic_spec<fmt::detail::precision_checker>(rep_specs.precision, precision_ref, ctx); fmt::detail::handle_dynamic_spec<fmt::detail::precision_checker>(rep_specs.precision, precision_ref, ctx);
// In `global_format_buffer` we will create a global format string // In `global_format_buffer` we will create a global format string
// e.g. "{:*^10%.1Q_%q}, 1.23q_m" => "{:*^10}" // e.g. "{:*^10%.1Q_%q}, 1.23_q_m" => "{:*^10}"
fmt::basic_memory_buffer<CharT> global_format_buffer; fmt::basic_memory_buffer<CharT> global_format_buffer;
auto to_gfb = std::back_inserter(global_format_buffer); auto to_gfb = std::back_inserter(global_format_buffer);
format_to(to_gfb, "{{:"); format_to(to_gfb, "{{:");
@ -466,7 +466,7 @@ public:
// In `quantity_buffer` we will have the representation and the unit formatted according to their // In `quantity_buffer` we will have the representation and the unit formatted according to their
// specification, ignoring global specifiers // specification, ignoring global specifiers
// e.g. "{:*^10%.1Q_%q}, 1.23q_m" => "1.2_m" // e.g. "{:*^10%.1Q_%q}, 1.23_q_m" => "1.2_m"
// TODO Avoid extra copying if width is not specified // TODO Avoid extra copying if width is not specified
fmt::basic_memory_buffer<CharT> quantity_buffer; fmt::basic_memory_buffer<CharT> quantity_buffer;
auto to_quantity_buffer = std::back_inserter(quantity_buffer); auto to_quantity_buffer = std::back_inserter(quantity_buffer);

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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_erg_per_s(unsigned long long l) { return power<erg_per_second, std::int64_t>(l); } constexpr auto operator"" _q_erg_per_s(unsigned long long l) { return power<erg_per_second, std::int64_t>(l); }
constexpr auto operator"" q_erg_per_s(long double l) { return power<erg_per_second, long double>(l); } constexpr auto operator"" _q_erg_per_s(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"" q_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"" q_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

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

@ -38,8 +38,8 @@ using speed = quantity<dim_speed, U, Rep>;
inline namespace literals { inline namespace literals {
// cmps // cmps
constexpr auto operator"" q_cm_per_s(unsigned long long l) { return speed<centimetre_per_second, std::int64_t>(l); } constexpr auto operator"" _q_cm_per_s(unsigned long long l) { return speed<centimetre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_cm_per_s(long double l) { return speed<centimetre_per_second, long double>(l); } constexpr auto operator"" _q_cm_per_s(long double l) { return speed<centimetre_per_second, 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"" q_s; using si::literals::operator"" _q_s;
} }

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

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

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

@ -39,8 +39,8 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals { inline namespace literals {
// ft2 // ft2
constexpr auto operator"" q_ft2(unsigned long long l) { return area<square_foot, std::int64_t>(l); } constexpr auto operator"" _q_ft2(unsigned long long l) { return area<square_foot, std::int64_t>(l); }
constexpr auto operator"" q_ft2(long double l) { return area<square_foot, long double>(l); } constexpr auto operator"" _q_ft2(long double l) { return area<square_foot, long double>(l); }
} }

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

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

8
src/include/units/physical/fps/energy.h
View File

@ -45,12 +45,12 @@ using energy = quantity<dim_energy, U, Rep>;
inline namespace literals { inline namespace literals {
constexpr auto operator"" q_ft_pdl(unsigned long long l) { return energy<foot_poundal, std::int64_t>(l); } constexpr auto operator"" _q_ft_pdl(unsigned long long l) { return energy<foot_poundal, std::int64_t>(l); }
constexpr auto operator"" q_ft_pdl(long double l) { return energy<foot_poundal, long double>(l); } constexpr auto operator"" _q_ft_pdl(long double l) { return energy<foot_poundal, long double>(l); }
// foot_pound force // foot_pound force
constexpr auto operator"" q_ft_lbf(unsigned long long l) { return energy<foot_pound_force, std::int64_t>(l); } constexpr auto operator"" _q_ft_lbf(unsigned long long l) { return energy<foot_pound_force, std::int64_t>(l); }
constexpr auto operator"" q_ft_lbf(long double l) { return energy<foot_pound_force, long double>(l); } constexpr auto operator"" _q_ft_lbf(long double l) { return energy<foot_pound_force, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/fps/force.h
View File

@ -49,16 +49,16 @@ using force = quantity<dim_force, U, Rep>;
inline namespace literals { inline namespace literals {
// poundal // poundal
constexpr auto operator"" q_pdl(unsigned long long l) { return force<poundal, std::int64_t>(l); } constexpr auto operator"" _q_pdl(unsigned long long l) { return force<poundal, std::int64_t>(l); }
constexpr auto operator"" q_pdl(long double l) { return force<poundal, long double>(l); } constexpr auto operator"" _q_pdl(long double l) { return force<poundal, long double>(l); }
// pound force // pound force
constexpr auto operator"" q_lbf(unsigned long long l) { return force<pound_force, std::int64_t>(l); } constexpr auto operator"" _q_lbf(unsigned long long l) { return force<pound_force, std::int64_t>(l); }
constexpr auto operator"" q_lbf(long double l) { return force<pound_force, long double>(l); } constexpr auto operator"" _q_lbf(long double l) { return force<pound_force, long double>(l); }
// kilopound force // kilopound force
constexpr auto operator"" q_klbf(unsigned long long l) { return force<kilopound_force, std::int64_t>(l); } constexpr auto operator"" _q_klbf(unsigned long long l) { return force<kilopound_force, std::int64_t>(l); }
constexpr auto operator"" q_klbf(long double l) { return force<kilopound_force, long double>(l); } constexpr auto operator"" _q_klbf(long double l) { return force<kilopound_force, long double>(l); }
} // namespace literals } // namespace literals

36
src/include/units/physical/fps/length.h
View File

@ -58,39 +58,39 @@ using length = quantity<dim_length, U, Rep>;
inline namespace literals { inline namespace literals {
// Thousandth // Thousandth
constexpr auto operator"" q_thou(unsigned long long l) { return length<thousandth, std::int64_t>(l); } constexpr auto operator"" _q_thou(unsigned long long l) { return length<thousandth, std::int64_t>(l); }
constexpr auto operator"" q_thou(long double l) { return length<thousandth, long double>(l); } constexpr auto operator"" _q_thou(long double l) { return length<thousandth, long double>(l); }
constexpr auto operator"" q_mil(unsigned long long l) { return length<thousandth, std::int64_t>(l); } constexpr auto operator"" _q_mil(unsigned long long l) { return length<thousandth, std::int64_t>(l); }
constexpr auto operator"" q_mil(long double l) { return length<thousandth, long double>(l); } constexpr auto operator"" _q_mil(long double l) { return length<thousandth, long double>(l); }
// Inch // Inch
constexpr auto operator"" q_in(unsigned long long l) { return length<inch, std::int64_t>(l); } constexpr auto operator"" _q_in(unsigned long long l) { return length<inch, std::int64_t>(l); }
constexpr auto operator"" q_in(long double l) { return length<inch, long double>(l); } constexpr auto operator"" _q_in(long double l) { return length<inch, long double>(l); }
// Foot // Foot
constexpr auto operator"" q_ft(unsigned long long l) { return length<foot, std::int64_t>(l); } constexpr auto operator"" _q_ft(unsigned long long l) { return length<foot, std::int64_t>(l); }
constexpr auto operator"" q_ft(long double l) { return length<foot, long double>(l); } constexpr auto operator"" _q_ft(long double l) { return length<foot, long double>(l); }
// Yard // Yard
constexpr auto operator"" q_yd(unsigned long long l) { return length<yard, std::int64_t>(l); } constexpr auto operator"" _q_yd(unsigned long long l) { return length<yard, std::int64_t>(l); }
constexpr auto operator"" q_yd(long double l) { return length<yard, long double>(l); } constexpr auto operator"" _q_yd(long double l) { return length<yard, long double>(l); }
// Fathom // Fathom
constexpr auto operator"" q_ftm(unsigned long long l) { return length<fathom, std::int64_t>(l); } constexpr auto operator"" _q_ftm(unsigned long long l) { return length<fathom, std::int64_t>(l); }
constexpr auto operator"" q_ftm(long double l) { return length<fathom, long double>(l); } constexpr auto operator"" _q_ftm(long double l) { return length<fathom, long double>(l); }
// Kiloyard // Kiloyard
constexpr auto operator"" q_kyd(unsigned long long l) { return length<kiloyard, std::int64_t>(l); } constexpr auto operator"" _q_kyd(unsigned long long l) { return length<kiloyard, std::int64_t>(l); }
constexpr auto operator"" q_kyd(long double l) { return length<kiloyard, long double>(l); } constexpr auto operator"" _q_kyd(long double l) { return length<kiloyard, long double>(l); }
// Mile // Mile
constexpr auto operator"" q_mile(unsigned long long l) { return length<mile, std::int64_t>(l); } constexpr auto operator"" _q_mile(unsigned long long l) { return length<mile, std::int64_t>(l); }
constexpr auto operator"" q_mile(long double l) { return length<mile, long double>(l); } constexpr auto operator"" _q_mile(long double l) { return length<mile, long double>(l); }
// Nautical mile // Nautical mile
constexpr auto operator"" q_naut_mi(unsigned long long l) { return length<nautical_mile, std::int64_t>(l); } constexpr auto operator"" _q_naut_mi(unsigned long long l) { return length<nautical_mile, std::int64_t>(l); }
constexpr auto operator"" q_naut_mi(long double l) { return length<nautical_mile, long double>(l); } constexpr auto operator"" _q_naut_mi(long double l) { return length<nautical_mile, long double>(l); }
} }

36
src/include/units/physical/fps/mass.h
View File

@ -55,40 +55,40 @@ struct long_ton : named_scaled_unit<long_ton, "ton (long)", no_prefix, ratio(2'2
inline namespace literals { inline namespace literals {
// Grain // Grain
constexpr auto operator"" q_gr(unsigned long long l) { return mass<grain, std::int64_t>(l); } constexpr auto operator"" _q_gr(unsigned long long l) { return mass<grain, std::int64_t>(l); }
constexpr auto operator"" q_gr(long double l) { return mass<grain, long double>(l); } constexpr auto operator"" _q_gr(long double l) { return mass<grain, long double>(l); }
// Dram // Dram
constexpr auto operator"" q_dr(unsigned long long l) { return mass<dram, std::int64_t>(l); } constexpr auto operator"" _q_dr(unsigned long long l) { return mass<dram, std::int64_t>(l); }
constexpr auto operator"" q_dr(long double l) { return mass<dram, long double>(l); } constexpr auto operator"" _q_dr(long double l) { return mass<dram, long double>(l); }
// Ounce // Ounce
constexpr auto operator"" q_oz(unsigned long long l) { return mass<ounce, std::int64_t>(l); } constexpr auto operator"" _q_oz(unsigned long long l) { return mass<ounce, std::int64_t>(l); }
constexpr auto operator"" q_oz(long double l) { return mass<ounce, long double>(l); } constexpr auto operator"" _q_oz(long double l) { return mass<ounce, long double>(l); }
// Pound // Pound
constexpr auto operator"" q_lb(unsigned long long l) { return mass<pound, std::int64_t>(l); } constexpr auto operator"" _q_lb(unsigned long long l) { return mass<pound, std::int64_t>(l); }
constexpr auto operator"" q_lb(long double l) { return mass<pound, long double>(l); } constexpr auto operator"" _q_lb(long double l) { return mass<pound, long double>(l); }
// Stone // Stone
constexpr auto operator"" q_st(unsigned long long l) { return mass<stone, std::int64_t>(l); } constexpr auto operator"" _q_st(unsigned long long l) { return mass<stone, std::int64_t>(l); }
constexpr auto operator"" q_st(long double l) { return mass<stone, long double>(l); } constexpr auto operator"" _q_st(long double l) { return mass<stone, long double>(l); }
// Quarter // Quarter
constexpr auto operator"" q_qr(unsigned long long l) { return mass<quarter, std::int64_t>(l); } constexpr auto operator"" _q_qr(unsigned long long l) { return mass<quarter, std::int64_t>(l); }
constexpr auto operator"" q_qr(long double l) { return mass<quarter, long double>(l); } constexpr auto operator"" _q_qr(long double l) { return mass<quarter, long double>(l); }
// Hundredweight // Hundredweight
constexpr auto operator"" q_cwt(unsigned long long l) { return mass<hundredweight, std::int64_t>(l); } constexpr auto operator"" _q_cwt(unsigned long long l) { return mass<hundredweight, std::int64_t>(l); }
constexpr auto operator"" q_cwt(long double l) { return mass<hundredweight, long double>(l); } constexpr auto operator"" _q_cwt(long double l) { return mass<hundredweight, long double>(l); }
// Short ton // Short ton
constexpr auto operator"" q_ston(unsigned long long l) { return mass<short_ton, std::int64_t>(l); } constexpr auto operator"" _q_ston(unsigned long long l) { return mass<short_ton, std::int64_t>(l); }
constexpr auto operator"" q_ston(long double l) { return mass<short_ton, long double>(l); } constexpr auto operator"" _q_ston(long double l) { return mass<short_ton, long double>(l); }
// Long Ton // Long Ton
constexpr auto operator"" q_lton(unsigned long long l) { return mass<long_ton, std::int64_t>(l); } constexpr auto operator"" _q_lton(unsigned long long l) { return mass<long_ton, std::int64_t>(l); }
constexpr auto operator"" q_lton(long double l) { return mass<long_ton, long double>(l); } constexpr auto operator"" _q_lton(long double l) { return mass<long_ton, long double>(l); }
} }

12
src/include/units/physical/fps/power.h
View File

@ -43,17 +43,17 @@ using power = quantity<dim_power, U, Rep>;
inline namespace literals { inline namespace literals {
// foot pound force per second // foot pound force per second
constexpr auto operator"" q_ft_pdl_per_s(unsigned long long l) { return power<foot_poundal_per_second, std::int64_t>(l); } constexpr auto operator"" _q_ft_pdl_per_s(unsigned long long l) { return power<foot_poundal_per_second, std::int64_t>(l); }
constexpr auto operator"" q_ft_pdl_per_s(long double l) { return power<foot_poundal_per_second, long double>(l); } constexpr auto operator"" _q_ft_pdl_per_s(long double l) { return power<foot_poundal_per_second, long double>(l); }
// foot pound force per second // foot pound force per second
constexpr auto operator"" q_ft_lbf_per_s(unsigned long long l) { return power<foot_pound_force_per_second, std::int64_t>(l); } constexpr auto operator"" _q_ft_lbf_per_s(unsigned long long l) { return power<foot_pound_force_per_second, std::int64_t>(l); }
constexpr auto operator"" q_ft_lbf_per_s(long double l) { return power<foot_pound_force_per_second, long double>(l); } constexpr auto operator"" _q_ft_lbf_per_s(long double l) { return power<foot_pound_force_per_second, long double>(l); }
constexpr auto operator"" q_hp(unsigned long long l) { return power<horse_power, std::int64_t>(l); } constexpr auto operator"" _q_hp(unsigned long long l) { return power<horse_power, std::int64_t>(l); }
constexpr auto operator"" q_hp(long double l) { return power<horse_power, long double>(l); } constexpr auto operator"" _q_hp(long double l) { return power<horse_power, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/fps/pressure.h
View File

@ -45,16 +45,16 @@ struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq,
inline namespace literals { inline namespace literals {
// Poundal per square foot // Poundal per square foot
constexpr auto operator"" q_pdl_per_ft2(unsigned long long l) { return pressure<poundal_per_foot_sq, std::int64_t>(l); } constexpr auto operator"" _q_pdl_per_ft2(unsigned long long l) { return pressure<poundal_per_foot_sq, std::int64_t>(l); }
constexpr auto operator"" q_pdl_per_ft2(long double l) { return pressure<poundal_per_foot_sq, long double>(l); } constexpr auto operator"" _q_pdl_per_ft2(long double l) { return pressure<poundal_per_foot_sq, long double>(l); }
// Pounds per square inch // Pounds per square inch
constexpr auto operator"" q_psi(unsigned long long l) { return pressure<pound_force_per_inch_sq, std::int64_t>(l); } constexpr auto operator"" _q_psi(unsigned long long l) { return pressure<pound_force_per_inch_sq, std::int64_t>(l); }
constexpr auto operator"" q_psi(long double l) { return pressure<pound_force_per_inch_sq, long double>(l); } constexpr auto operator"" _q_psi(long double l) { return pressure<pound_force_per_inch_sq, long double>(l); }
// kilopounds per square inch // kilopounds per square inch
constexpr auto operator"" q_kpsi(unsigned long long l) { return pressure<kilopound_force_per_inch_sq, std::int64_t>(l); } constexpr auto operator"" _q_kpsi(unsigned long long l) { return pressure<kilopound_force_per_inch_sq, std::int64_t>(l); }
constexpr auto operator"" q_kpsi(long double l) { return pressure<kilopound_force_per_inch_sq, long double>(l); } constexpr auto operator"" _q_kpsi(long double l) { return pressure<kilopound_force_per_inch_sq, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/fps/speed.h
View File

@ -44,14 +44,14 @@ struct knot : alias_unit<nautical_mile_per_hour, "knot", no_prefix> {};
inline namespace literals { inline namespace literals {
constexpr auto operator"" q_ft_per_s(unsigned long long l) { return speed<foot_per_second, std::int64_t>(l); } constexpr auto operator"" _q_ft_per_s(unsigned long long l) { return speed<foot_per_second, std::int64_t>(l); }
constexpr auto operator"" q_ft_per_s(long double l) { return speed<foot_per_second, long double>(l); } constexpr auto operator"" _q_ft_per_s(long double l) { return speed<foot_per_second, long double>(l); }
constexpr auto operator"" q_mph(unsigned long long l) { return speed<mile_per_hour, std::int64_t>(l); } constexpr auto operator"" _q_mph(unsigned long long l) { return speed<mile_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_mph(long double l) { return speed<mile_per_hour, long double>(l); } constexpr auto operator"" _q_mph(long double l) { return speed<mile_per_hour, long double>(l); }
constexpr auto operator"" q_knot(unsigned long long l) { return speed<knot, std::int64_t>(l); } constexpr auto operator"" _q_knot(unsigned long long l) { return speed<knot, std::int64_t>(l); }
constexpr auto operator"" q_knot(long double l) { return speed<knot, long double>(l); } constexpr auto operator"" _q_knot(long double l) { return speed<knot, long double>(l); }
} // namespace literals } // namespace literals

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

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

8
src/include/units/physical/fps/volume.h
View File

@ -39,12 +39,12 @@ using volume = quantity<dim_volume, U, Rep>;
inline namespace literals { inline namespace literals {
// ft3 // ft3
constexpr auto operator"" q_ft3(unsigned long long l) { return volume<cubic_foot, std::int64_t>(l); } constexpr auto operator"" _q_ft3(unsigned long long l) { return volume<cubic_foot, std::int64_t>(l); }
constexpr auto operator"" q_ft3(long double l) { return volume<cubic_foot, long double>(l); } constexpr auto operator"" _q_ft3(long double l) { return volume<cubic_foot, long double>(l); }
// yard3 // yard3
constexpr auto operator"" q_yd3(unsigned long long l) { return volume<cubic_yard, std::int64_t>(l); } constexpr auto operator"" _q_yd3(unsigned long long l) { return volume<cubic_yard, std::int64_t>(l); }
constexpr auto operator"" q_yd3(long double l) { return volume<cubic_yard, long double>(l); } constexpr auto operator"" _q_yd3(long double l) { return volume<cubic_yard, 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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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/speed.h
View File

@ -32,8 +32,8 @@ struct mile_per_hour : deduced_unit<mile_per_hour, si::dim_speed, international:
inline namespace literals { inline namespace literals {
// mph // mph
constexpr auto operator"" q_mi_per_h(unsigned long long l) { return si::speed<mile_per_hour, std::int64_t>(l); } constexpr auto operator"" _q_mi_per_h(unsigned long long l) { return si::speed<mile_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_mi_per_h(long double l) { return si::speed<mile_per_hour, long double>(l); } constexpr auto operator"" _q_mi_per_h(long double l) { return si::speed<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"" q_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"" q_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

2
src/include/units/physical/natural/dimensions.h
View File

@ -61,6 +61,6 @@ template<Unit U, ScalableNumber Rep = double>
using energy = quantity<dim_force, U, Rep>; using energy = quantity<dim_force, U, Rep>;
// Typical UDLs will not work here as the same units are reused by many quantities. // Typical UDLs will not work here as the same units are reused by many quantities.
// Should we define some strange ones (i.e. q_mass_GeV)? // Should we define some strange ones (i.e. _q_mass_GeV)?
} // namespace units::physical::natural } // namespace units::physical::natural

84
src/include/units/physical/si/absorbed_dose.h
View File

@ -60,88 +60,88 @@ using absorbed_dose = quantity<dim_absorbed_dose, U, Rep>;
inline namespace literals { inline namespace literals {
// G // G
constexpr auto operator"" q_Gy(unsigned long long l) { return absorbed_dose<gray, std::int64_t>(l); } constexpr auto operator"" _q_Gy(unsigned long long l) { return absorbed_dose<gray, std::int64_t>(l); }
constexpr auto operator"" q_Gy(long double l) { return absorbed_dose<gray, long double>(l); } constexpr auto operator"" _q_Gy(long double l) { return absorbed_dose<gray, long double>(l); }
// yGy // yGy
constexpr auto operator"" q_yGy(unsigned long long l) { return absorbed_dose<yoctogray, std::int64_t>(l); } constexpr auto operator"" _q_yGy(unsigned long long l) { return absorbed_dose<yoctogray, std::int64_t>(l); }
constexpr auto operator"" q_yGy(long double l) { return absorbed_dose<yoctogray, long double>(l); } constexpr auto operator"" _q_yGy(long double l) { return absorbed_dose<yoctogray, long double>(l); }
// zGy // zGy
constexpr auto operator"" q_zGy(unsigned long long l) { return absorbed_dose<zeptogray, std::int64_t>(l); } constexpr auto operator"" _q_zGy(unsigned long long l) { return absorbed_dose<zeptogray, std::int64_t>(l); }
constexpr auto operator"" q_zGy(long double l) { return absorbed_dose<zeptogray, long double>(l); } constexpr auto operator"" _q_zGy(long double l) { return absorbed_dose<zeptogray, long double>(l); }
// aGy // aGy
constexpr auto operator"" q_aGy(unsigned long long l) { return absorbed_dose<attogray, std::int64_t>(l); } constexpr auto operator"" _q_aGy(unsigned long long l) { return absorbed_dose<attogray, std::int64_t>(l); }
constexpr auto operator"" q_aGy(long double l) { return absorbed_dose<attogray, long double>(l); } constexpr auto operator"" _q_aGy(long double l) { return absorbed_dose<attogray, long double>(l); }
// fGy // fGy
constexpr auto operator"" q_fGy(unsigned long long l) { return absorbed_dose<femtogray, std::int64_t>(l); } constexpr auto operator"" _q_fGy(unsigned long long l) { return absorbed_dose<femtogray, std::int64_t>(l); }
constexpr auto operator"" q_fGy(long double l) { return absorbed_dose<femtogray, long double>(l); } constexpr auto operator"" _q_fGy(long double l) { return absorbed_dose<femtogray, long double>(l); }
// pGy // pGy
constexpr auto operator"" q_pGy(unsigned long long l) { return absorbed_dose<picogray, std::int64_t>(l); } constexpr auto operator"" _q_pGy(unsigned long long l) { return absorbed_dose<picogray, std::int64_t>(l); }
constexpr auto operator"" q_pGy(long double l) { return absorbed_dose<picogray, long double>(l); } constexpr auto operator"" _q_pGy(long double l) { return absorbed_dose<picogray, long double>(l); }
// nGy // nGy
constexpr auto operator"" q_nGy(unsigned long long l) { return absorbed_dose<nanogray, std::int64_t>(l); } constexpr auto operator"" _q_nGy(unsigned long long l) { return absorbed_dose<nanogray, std::int64_t>(l); }
constexpr auto operator"" q_nGy(long double l) { return absorbed_dose<nanogray, long double>(l); } constexpr auto operator"" _q_nGy(long double l) { return absorbed_dose<nanogray, long double>(l); }
// uGy // uGy
constexpr auto operator"" q_uGy(unsigned long long l) { return absorbed_dose<microgray, std::int64_t>(l); } constexpr auto operator"" _q_uGy(unsigned long long l) { return absorbed_dose<microgray, std::int64_t>(l); }
constexpr auto operator"" q_uGy(long double l) { return absorbed_dose<microgray, long double>(l); } constexpr auto operator"" _q_uGy(long double l) { return absorbed_dose<microgray, long double>(l); }
// mGy // mGy
constexpr auto operator"" q_mGy(unsigned long long l) { return absorbed_dose<milligray, std::int64_t>(l); } constexpr auto operator"" _q_mGy(unsigned long long l) { return absorbed_dose<milligray, std::int64_t>(l); }
constexpr auto operator"" q_mGy(long double l) { return absorbed_dose<milligray, long double>(l); } constexpr auto operator"" _q_mGy(long double l) { return absorbed_dose<milligray, long double>(l); }
// cGy // cGy
constexpr auto operator"" q_cGy(unsigned long long l) { return absorbed_dose<centigray, std::int64_t>(l); } constexpr auto operator"" _q_cGy(unsigned long long l) { return absorbed_dose<centigray, std::int64_t>(l); }
constexpr auto operator"" q_cGy(long double l) { return absorbed_dose<centigray, long double>(l); } constexpr auto operator"" _q_cGy(long double l) { return absorbed_dose<centigray, long double>(l); }
// dGy // dGy
constexpr auto operator"" q_dGy(unsigned long long l) { return absorbed_dose<decigray, std::int64_t>(l); } constexpr auto operator"" _q_dGy(unsigned long long l) { return absorbed_dose<decigray, std::int64_t>(l); }
constexpr auto operator"" q_dGy(long double l) { return absorbed_dose<decigray, long double>(l); } constexpr auto operator"" _q_dGy(long double l) { return absorbed_dose<decigray, long double>(l); }
// daGy // daGy
constexpr auto operator"" q_daGy(unsigned long long l) { return absorbed_dose<decagray, std::int64_t>(l); } constexpr auto operator"" _q_daGy(unsigned long long l) { return absorbed_dose<decagray, std::int64_t>(l); }
constexpr auto operator"" q_daGy(long double l) { return absorbed_dose<decagray, long double>(l); } constexpr auto operator"" _q_daGy(long double l) { return absorbed_dose<decagray, long double>(l); }
// hGy // hGy
constexpr auto operator"" q_hGy(unsigned long long l) { return absorbed_dose<hectogray, std::int64_t>(l); } constexpr auto operator"" _q_hGy(unsigned long long l) { return absorbed_dose<hectogray, std::int64_t>(l); }
constexpr auto operator"" q_hGy(long double l) { return absorbed_dose<hectogray, long double>(l); } constexpr auto operator"" _q_hGy(long double l) { return absorbed_dose<hectogray, long double>(l); }
// kGy // kGy
constexpr auto operator"" q_kGy(unsigned long long l) { return absorbed_dose<kilogray, std::int64_t>(l); } constexpr auto operator"" _q_kGy(unsigned long long l) { return absorbed_dose<kilogray, std::int64_t>(l); }
constexpr auto operator"" q_kGy(long double l) { return absorbed_dose<kilogray, long double>(l); } constexpr auto operator"" _q_kGy(long double l) { return absorbed_dose<kilogray, long double>(l); }
// MGy // MGy
constexpr auto operator"" q_MGy(unsigned long long l) { return absorbed_dose<megagray, std::int64_t>(l); } constexpr auto operator"" _q_MGy(unsigned long long l) { return absorbed_dose<megagray, std::int64_t>(l); }
constexpr auto operator"" q_MGy(long double l) { return absorbed_dose<megagray, long double>(l); } constexpr auto operator"" _q_MGy(long double l) { return absorbed_dose<megagray, long double>(l); }
// GGy // GGy
constexpr auto operator"" q_GGy(unsigned long long l) { return absorbed_dose<gigagray, std::int64_t>(l); } constexpr auto operator"" _q_GGy(unsigned long long l) { return absorbed_dose<gigagray, std::int64_t>(l); }
constexpr auto operator"" q_GGy(long double l) { return absorbed_dose<gigagray, long double>(l); } constexpr auto operator"" _q_GGy(long double l) { return absorbed_dose<gigagray, long double>(l); }
// TGy // TGy
constexpr auto operator"" q_TGy(unsigned long long l) { return absorbed_dose<teragray, std::int64_t>(l); } constexpr auto operator"" _q_TGy(unsigned long long l) { return absorbed_dose<teragray, std::int64_t>(l); }
constexpr auto operator"" q_TGy(long double l) { return absorbed_dose<teragray, long double>(l); } constexpr auto operator"" _q_TGy(long double l) { return absorbed_dose<teragray, long double>(l); }
// PGy // PGy
constexpr auto operator"" q_PGy(unsigned long long l) { return absorbed_dose<petagray, std::int64_t>(l); } constexpr auto operator"" _q_PGy(unsigned long long l) { return absorbed_dose<petagray, std::int64_t>(l); }
constexpr auto operator"" q_PGy(long double l) { return absorbed_dose<petagray, long double>(l); } constexpr auto operator"" _q_PGy(long double l) { return absorbed_dose<petagray, long double>(l); }
// EGy // EGy
constexpr auto operator"" q_EGy(unsigned long long l) { return absorbed_dose<exagray, std::int64_t>(l); } constexpr auto operator"" _q_EGy(unsigned long long l) { return absorbed_dose<exagray, std::int64_t>(l); }
constexpr auto operator"" q_EGy(long double l) { return absorbed_dose<exagray, long double>(l); } constexpr auto operator"" _q_EGy(long double l) { return absorbed_dose<exagray, long double>(l); }
// ZGy // ZGy
constexpr auto operator"" q_ZGy(unsigned long long l) { return absorbed_dose<zettagray, std::int64_t>(l); } constexpr auto operator"" _q_ZGy(unsigned long long l) { return absorbed_dose<zettagray, std::int64_t>(l); }
constexpr auto operator"" q_ZGy(long double l) { return absorbed_dose<zettagray, long double>(l); } constexpr auto operator"" _q_ZGy(long double l) { return absorbed_dose<zettagray, long double>(l); }
// YGy // YGy
constexpr auto operator"" q_YGy(unsigned long long l) { return absorbed_dose<yottagray, std::int64_t>(l); } constexpr auto operator"" _q_YGy(unsigned long long l) { return absorbed_dose<yottagray, std::int64_t>(l); }
constexpr auto operator"" q_YGy(long double l) { return absorbed_dose<yottagray, long double>(l); } constexpr auto operator"" _q_YGy(long double l) { return absorbed_dose<yottagray, 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"" q_m_per_s2(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); } constexpr auto operator"" _q_m_per_s2(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); }
constexpr auto operator"" q_m_per_s2(long double l) { return acceleration<metre_per_second_sq, long double>(l); } constexpr auto operator"" _q_m_per_s2(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
} // namespace literals } // namespace literals

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

@ -38,8 +38,8 @@ using angle = quantity<dim_angle, U, Rep>;
inline namespace literals { inline namespace literals {
// rad // rad
constexpr auto operator"" q_rad(unsigned long long l) { return angle<radian, std::int64_t>(l); } constexpr auto operator"" _q_rad(unsigned long long l) { return angle<radian, std::int64_t>(l); }
constexpr auto operator"" q_rad(long double l) { return angle<radian, long double>(l); } constexpr auto operator"" _q_rad(long double l) { return angle<radian, long double>(l); }
} // namespace literals } // namespace literals

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

@ -40,8 +40,8 @@ using angular_velocity = quantity<dim_angular_velocity, U, Rep>;
inline namespace literals { inline namespace literals {
// rad / s // rad / s
constexpr auto operator"" q_rad_per_s(unsigned long long l) { return angular_velocity<radian_per_second, std::int64_t>(l); } constexpr auto operator"" _q_rad_per_s(unsigned long long l) { return angular_velocity<radian_per_second, std::int64_t>(l); }
constexpr auto operator"" q_rad_per_s(long double l) { return angular_velocity<radian_per_second, long double>(l); } constexpr auto operator"" _q_rad_per_s(long double l) { return angular_velocity<radian_per_second, long double>(l); }
} // namespace literals } // namespace literals

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

@ -60,92 +60,92 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals { inline namespace literals {
// m2 // m2
constexpr auto operator"" q_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"" q_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); }
// ym2 // ym2
constexpr auto operator"" q_ym2(unsigned long long l) { return area<square_yoctometre, std::int64_t>(l); } constexpr auto operator"" _q_ym2(unsigned long long l) { return area<square_yoctometre, std::int64_t>(l); }
constexpr auto operator"" q_ym2(long double l) { return area<square_yoctometre, long double>(l); } constexpr auto operator"" _q_ym2(long double l) { return area<square_yoctometre, long double>(l); }
// zm2 // zm2
constexpr auto operator"" q_zm2(unsigned long long l) { return area<square_zeptometre, std::int64_t>(l); } constexpr auto operator"" _q_zm2(unsigned long long l) { return area<square_zeptometre, std::int64_t>(l); }
constexpr auto operator"" q_zm2(long double l) { return area<square_zeptometre, long double>(l); } constexpr auto operator"" _q_zm2(long double l) { return area<square_zeptometre, long double>(l); }
// am2 // am2
constexpr auto operator"" q_am2(unsigned long long l) { return area<square_attometre, std::int64_t>(l); } constexpr auto operator"" _q_am2(unsigned long long l) { return area<square_attometre, std::int64_t>(l); }
constexpr auto operator"" q_am2(long double l) { return area<square_attometre, long double>(l); } constexpr auto operator"" _q_am2(long double l) { return area<square_attometre, long double>(l); }
// fm2 // fm2
constexpr auto operator"" q_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"" q_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); }
// pm2 // pm2
constexpr auto operator"" q_pm2(unsigned long long l) { return area<square_picometre, std::int64_t>(l); } constexpr auto operator"" _q_pm2(unsigned long long l) { return area<square_picometre, std::int64_t>(l); }
constexpr auto operator"" q_pm2(long double l) { return area<square_picometre, long double>(l); } constexpr auto operator"" _q_pm2(long double l) { return area<square_picometre, long double>(l); }
// nm2 // nm2
constexpr auto operator"" q_nm2(unsigned long long l) { return area<square_nanometre, std::int64_t>(l); } constexpr auto operator"" _q_nm2(unsigned long long l) { return area<square_nanometre, std::int64_t>(l); }
constexpr auto operator"" q_nm2(long double l) { return area<square_nanometre, long double>(l); } constexpr auto operator"" _q_nm2(long double l) { return area<square_nanometre, long double>(l); }
// um2 // um2
constexpr auto operator"" q_um2(unsigned long long l) { return area<square_micrometre, std::int64_t>(l); } constexpr auto operator"" _q_um2(unsigned long long l) { return area<square_micrometre, std::int64_t>(l); }
constexpr auto operator"" q_um2(long double l) { return area<square_micrometre, long double>(l); } constexpr auto operator"" _q_um2(long double l) { return area<square_micrometre, long double>(l); }
// mm2 // mm2
constexpr auto operator"" q_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"" q_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"" q_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"" q_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); }
// dm2 // dm2
constexpr auto operator"" q_dm2(unsigned long long l) { return area<square_decimetre, std::int64_t>(l); } constexpr auto operator"" _q_dm2(unsigned long long l) { return area<square_decimetre, std::int64_t>(l); }
constexpr auto operator"" q_dm2(long double l) { return area<square_decimetre, long double>(l); } constexpr auto operator"" _q_dm2(long double l) { return area<square_decimetre, long double>(l); }
// dam2 // dam2
constexpr auto operator"" q_dam2(unsigned long long l) { return area<square_decametre, std::int64_t>(l); } constexpr auto operator"" _q_dam2(unsigned long long l) { return area<square_decametre, std::int64_t>(l); }
constexpr auto operator"" q_dam2(long double l) { return area<square_decametre, long double>(l); } constexpr auto operator"" _q_dam2(long double l) { return area<square_decametre, long double>(l); }
// hm2 // hm2
constexpr auto operator"" q_hm2(unsigned long long l) { return area<square_hectometre, std::int64_t>(l); } constexpr auto operator"" _q_hm2(unsigned long long l) { return area<square_hectometre, std::int64_t>(l); }
constexpr auto operator"" q_hm2(long double l) { return area<square_hectometre, long double>(l); } constexpr auto operator"" _q_hm2(long double l) { return area<square_hectometre, long double>(l); }
// km2 // km2
constexpr auto operator"" q_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"" q_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); }
// Mm2 // Mm2
constexpr auto operator"" q_Mm2(unsigned long long l) { return area<square_megametre, std::int64_t>(l); } constexpr auto operator"" _q_Mm2(unsigned long long l) { return area<square_megametre, std::int64_t>(l); }
constexpr auto operator"" q_Mm2(long double l) { return area<square_megametre, long double>(l); } constexpr auto operator"" _q_Mm2(long double l) { return area<square_megametre, long double>(l); }
// Gm2 // Gm2
constexpr auto operator"" q_Gm2(unsigned long long l) { return area<square_gigametre, std::int64_t>(l); } constexpr auto operator"" _q_Gm2(unsigned long long l) { return area<square_gigametre, std::int64_t>(l); }
constexpr auto operator"" q_Gm2(long double l) { return area<square_gigametre, long double>(l); } constexpr auto operator"" _q_Gm2(long double l) { return area<square_gigametre, long double>(l); }
// Tm2 // Tm2
constexpr auto operator"" q_Tm2(unsigned long long l) { return area<square_terametre, std::int64_t>(l); } constexpr auto operator"" _q_Tm2(unsigned long long l) { return area<square_terametre, std::int64_t>(l); }
constexpr auto operator"" q_Tm2(long double l) { return area<square_terametre, long double>(l); } constexpr auto operator"" _q_Tm2(long double l) { return area<square_terametre, long double>(l); }
// Pm2 // Pm2
constexpr auto operator"" q_Pm2(unsigned long long l) { return area<square_petametre, std::int64_t>(l); } constexpr auto operator"" _q_Pm2(unsigned long long l) { return area<square_petametre, std::int64_t>(l); }
constexpr auto operator"" q_Pm2(long double l) { return area<square_petametre, long double>(l); } constexpr auto operator"" _q_Pm2(long double l) { return area<square_petametre, long double>(l); }
// Em2 // Em2
constexpr auto operator"" q_Em2(unsigned long long l) { return area<square_exametre, std::int64_t>(l); } constexpr auto operator"" _q_Em2(unsigned long long l) { return area<square_exametre, std::int64_t>(l); }
constexpr auto operator"" q_Em2(long double l) { return area<square_exametre, long double>(l); } constexpr auto operator"" _q_Em2(long double l) { return area<square_exametre, long double>(l); }
// Zm2 // Zm2
constexpr auto operator"" q_Zm2(unsigned long long l) { return area<square_zettametre, std::int64_t>(l); } constexpr auto operator"" _q_Zm2(unsigned long long l) { return area<square_zettametre, std::int64_t>(l); }
constexpr auto operator"" q_Zm2(long double l) { return area<square_zettametre, long double>(l); } constexpr auto operator"" _q_Zm2(long double l) { return area<square_zettametre, long double>(l); }
// Ym2 // Ym2
constexpr auto operator"" q_Ym2(unsigned long long l) { return area<square_yottametre, std::int64_t>(l); } constexpr auto operator"" _q_Ym2(unsigned long long l) { return area<square_yottametre, std::int64_t>(l); }
constexpr auto operator"" q_Ym2(long double l) { return area<square_yottametre, long double>(l); } constexpr auto operator"" _q_Ym2(long double l) { return area<square_yottametre, long double>(l); }
// ha // ha
constexpr auto operator"" q_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"" q_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

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

@ -60,88 +60,88 @@ using capacitance = quantity<dim_capacitance, U, Rep>;
inline namespace literals { inline namespace literals {
// F // F
constexpr auto operator"" q_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"" q_F(long double l) { return capacitance<farad, long double>(l); } constexpr auto operator"" _q_F(long double l) { return capacitance<farad, long double>(l); }
// yF // yF
constexpr auto operator"" q_yF(unsigned long long l) { return capacitance<yoctofarad, std::int64_t>(l); } constexpr auto operator"" _q_yF(unsigned long long l) { return capacitance<yoctofarad, std::int64_t>(l); }
constexpr auto operator"" q_yF(long double l) { return capacitance<yoctofarad, long double>(l); } constexpr auto operator"" _q_yF(long double l) { return capacitance<yoctofarad, long double>(l); }
// zF // zF
constexpr auto operator"" q_zF(unsigned long long l) { return capacitance<zeptofarad, std::int64_t>(l); } constexpr auto operator"" _q_zF(unsigned long long l) { return capacitance<zeptofarad, std::int64_t>(l); }
constexpr auto operator"" q_zF(long double l) { return capacitance<zeptofarad, long double>(l); } constexpr auto operator"" _q_zF(long double l) { return capacitance<zeptofarad, long double>(l); }
// aF // aF
constexpr auto operator"" q_aF(unsigned long long l) { return capacitance<attofarad, std::int64_t>(l); } constexpr auto operator"" _q_aF(unsigned long long l) { return capacitance<attofarad, std::int64_t>(l); }
constexpr auto operator"" q_aF(long double l) { return capacitance<attofarad, long double>(l); } constexpr auto operator"" _q_aF(long double l) { return capacitance<attofarad, long double>(l); }
// fF // fF
constexpr auto operator"" q_fF(unsigned long long l) { return capacitance<femtofarad, std::int64_t>(l); } constexpr auto operator"" _q_fF(unsigned long long l) { return capacitance<femtofarad, std::int64_t>(l); }
constexpr auto operator"" q_fF(long double l) { return capacitance<femtofarad, long double>(l); } constexpr auto operator"" _q_fF(long double l) { return capacitance<femtofarad, long double>(l); }
// pF // pF
constexpr auto operator"" q_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"" q_pF(long double l) { return capacitance<picofarad, long double>(l); } constexpr auto operator"" _q_pF(long double l) { return capacitance<picofarad, long double>(l); }
// nF // nF
constexpr auto operator"" q_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"" q_nF(long double l) { return capacitance<nanofarad, long double>(l); } constexpr auto operator"" _q_nF(long double l) { return capacitance<nanofarad, long double>(l); }
// uF // uF
constexpr auto operator"" q_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"" q_uF(long double l) { return capacitance<microfarad, long double>(l); } constexpr auto operator"" _q_uF(long double l) { return capacitance<microfarad, long double>(l); }
// mF // mF
constexpr auto operator"" q_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"" q_mF(long double l) { return capacitance<millifarad, long double>(l); } constexpr auto operator"" _q_mF(long double l) { return capacitance<millifarad, long double>(l); }
// cF // cF
constexpr auto operator"" q_cF(unsigned long long l) { return capacitance<centifarad, std::int64_t>(l); } constexpr auto operator"" _q_cF(unsigned long long l) { return capacitance<centifarad, std::int64_t>(l); }
constexpr auto operator"" q_cF(long double l) { return capacitance<centifarad, long double>(l); } constexpr auto operator"" _q_cF(long double l) { return capacitance<centifarad, long double>(l); }
// dF // dF
constexpr auto operator"" q_dF(unsigned long long l) { return capacitance<decifarad, std::int64_t>(l); } constexpr auto operator"" _q_dF(unsigned long long l) { return capacitance<decifarad, std::int64_t>(l); }
constexpr auto operator"" q_dF(long double l) { return capacitance<decifarad, long double>(l); } constexpr auto operator"" _q_dF(long double l) { return capacitance<decifarad, long double>(l); }
// daF // daF
constexpr auto operator"" q_daF(unsigned long long l) { return capacitance<decafarad, std::int64_t>(l); } constexpr auto operator"" _q_daF(unsigned long long l) { return capacitance<decafarad, std::int64_t>(l); }
constexpr auto operator"" q_daF(long double l) { return capacitance<decafarad, long double>(l); } constexpr auto operator"" _q_daF(long double l) { return capacitance<decafarad, long double>(l); }
// hF // hF
constexpr auto operator"" q_hF(unsigned long long l) { return capacitance<hectofarad, std::int64_t>(l); } constexpr auto operator"" _q_hF(unsigned long long l) { return capacitance<hectofarad, std::int64_t>(l); }
constexpr auto operator"" q_hF(long double l) { return capacitance<hectofarad, long double>(l); } constexpr auto operator"" _q_hF(long double l) { return capacitance<hectofarad, long double>(l); }
// kF // kF
constexpr auto operator"" q_kF(unsigned long long l) { return capacitance<kilofarad, std::int64_t>(l); } constexpr auto operator"" _q_kF(unsigned long long l) { return capacitance<kilofarad, std::int64_t>(l); }
constexpr auto operator"" q_kF(long double l) { return capacitance<kilofarad, long double>(l); } constexpr auto operator"" _q_kF(long double l) { return capacitance<kilofarad, long double>(l); }
// MF // MF
constexpr auto operator"" q_MF(unsigned long long l) { return capacitance<megafarad, std::int64_t>(l); } constexpr auto operator"" _q_MF(unsigned long long l) { return capacitance<megafarad, std::int64_t>(l); }
constexpr auto operator"" q_MF(long double l) { return capacitance<megafarad, long double>(l); } constexpr auto operator"" _q_MF(long double l) { return capacitance<megafarad, long double>(l); }
// GF // GF
constexpr auto operator"" q_GF(unsigned long long l) { return capacitance<gigafarad, std::int64_t>(l); } constexpr auto operator"" _q_GF(unsigned long long l) { return capacitance<gigafarad, std::int64_t>(l); }
constexpr auto operator"" q_GF(long double l) { return capacitance<gigafarad, long double>(l); } constexpr auto operator"" _q_GF(long double l) { return capacitance<gigafarad, long double>(l); }
// TF // TF
constexpr auto operator"" q_TF(unsigned long long l) { return capacitance<terafarad, std::int64_t>(l); } constexpr auto operator"" _q_TF(unsigned long long l) { return capacitance<terafarad, std::int64_t>(l); }
constexpr auto operator"" q_TF(long double l) { return capacitance<terafarad, long double>(l); } constexpr auto operator"" _q_TF(long double l) { return capacitance<terafarad, long double>(l); }
// PF // PF
constexpr auto operator"" q_PF(unsigned long long l) { return capacitance<petafarad, std::int64_t>(l); } constexpr auto operator"" _q_PF(unsigned long long l) { return capacitance<petafarad, std::int64_t>(l); }
constexpr auto operator"" q_PF(long double l) { return capacitance<petafarad, long double>(l); } constexpr auto operator"" _q_PF(long double l) { return capacitance<petafarad, long double>(l); }
// EF // EF
constexpr auto operator"" q_EF(unsigned long long l) { return capacitance<exafarad, std::int64_t>(l); } constexpr auto operator"" _q_EF(unsigned long long l) { return capacitance<exafarad, std::int64_t>(l); }
constexpr auto operator"" q_EF(long double l) { return capacitance<exafarad, long double>(l); } constexpr auto operator"" _q_EF(long double l) { return capacitance<exafarad, long double>(l); }
// ZF // ZF
constexpr auto operator"" q_ZF(unsigned long long l) { return capacitance<zettafarad, std::int64_t>(l); } constexpr auto operator"" _q_ZF(unsigned long long l) { return capacitance<zettafarad, std::int64_t>(l); }
constexpr auto operator"" q_ZF(long double l) { return capacitance<zettafarad, long double>(l); } constexpr auto operator"" _q_ZF(long double l) { return capacitance<zettafarad, long double>(l); }
// YF // YF
constexpr auto operator"" q_YF(unsigned long long l) { return capacitance<yottafarad, std::int64_t>(l); } constexpr auto operator"" _q_YF(unsigned long long l) { return capacitance<yottafarad, std::int64_t>(l); }
constexpr auto operator"" q_YF(long double l) { return capacitance<yottafarad, long double>(l); } constexpr auto operator"" _q_YF(long double l) { return capacitance<yottafarad, long double>(l); }
} // namespace literals } // namespace literals

88
src/include/units/physical/si/catalytic_activity.h
View File

@ -62,92 +62,92 @@ using catalytic_activity = quantity<dim_catalytic_activity, U, Rep>;
inline namespace literals { inline namespace literals {
// kat // kat
constexpr auto operator"" q_kat(unsigned long long l) { return catalytic_activity<katal, std::int64_t>(l); } constexpr auto operator"" _q_kat(unsigned long long l) { return catalytic_activity<katal, std::int64_t>(l); }
constexpr auto operator"" q_kat(long double l) { return catalytic_activity<katal, long double>(l); } constexpr auto operator"" _q_kat(long double l) { return catalytic_activity<katal, long double>(l); }
// ykat // ykat
constexpr auto operator"" q_ykat(unsigned long long l) { return catalytic_activity<yoctokatal, std::int64_t>(l); } constexpr auto operator"" _q_ykat(unsigned long long l) { return catalytic_activity<yoctokatal, std::int64_t>(l); }
constexpr auto operator"" q_ykat(long double l) { return catalytic_activity<yoctokatal, long double>(l); } constexpr auto operator"" _q_ykat(long double l) { return catalytic_activity<yoctokatal, long double>(l); }
// zkat // zkat
constexpr auto operator"" q_zkat(unsigned long long l) { return catalytic_activity<zeptokatal, std::int64_t>(l); } constexpr auto operator"" _q_zkat(unsigned long long l) { return catalytic_activity<zeptokatal, std::int64_t>(l); }
constexpr auto operator"" q_zkat(long double l) { return catalytic_activity<zeptokatal, long double>(l); } constexpr auto operator"" _q_zkat(long double l) { return catalytic_activity<zeptokatal, long double>(l); }
// akat // akat
constexpr auto operator"" q_akat(unsigned long long l) { return catalytic_activity<attokatal, std::int64_t>(l); } constexpr auto operator"" _q_akat(unsigned long long l) { return catalytic_activity<attokatal, std::int64_t>(l); }
constexpr auto operator"" q_akat(long double l) { return catalytic_activity<attokatal, long double>(l); } constexpr auto operator"" _q_akat(long double l) { return catalytic_activity<attokatal, long double>(l); }
// fkat // fkat
constexpr auto operator"" q_fkat(unsigned long long l) { return catalytic_activity<femtokatal, std::int64_t>(l); } constexpr auto operator"" _q_fkat(unsigned long long l) { return catalytic_activity<femtokatal, std::int64_t>(l); }
constexpr auto operator"" q_fkat(long double l) { return catalytic_activity<femtokatal, long double>(l); } constexpr auto operator"" _q_fkat(long double l) { return catalytic_activity<femtokatal, long double>(l); }
// pkat // pkat
constexpr auto operator"" q_pkat(unsigned long long l) { return catalytic_activity<picokatal, std::int64_t>(l); } constexpr auto operator"" _q_pkat(unsigned long long l) { return catalytic_activity<picokatal, std::int64_t>(l); }
constexpr auto operator"" q_pkat(long double l) { return catalytic_activity<picokatal, long double>(l); } constexpr auto operator"" _q_pkat(long double l) { return catalytic_activity<picokatal, long double>(l); }
// nkat // nkat
constexpr auto operator"" q_nkat(unsigned long long l) { return catalytic_activity<nanokatal, std::int64_t>(l); } constexpr auto operator"" _q_nkat(unsigned long long l) { return catalytic_activity<nanokatal, std::int64_t>(l); }
constexpr auto operator"" q_nkat(long double l) { return catalytic_activity<nanokatal, long double>(l); } constexpr auto operator"" _q_nkat(long double l) { return catalytic_activity<nanokatal, long double>(l); }
// ukat // ukat
constexpr auto operator"" q_ukat(unsigned long long l) { return catalytic_activity<microkatal, std::int64_t>(l); } constexpr auto operator"" _q_ukat(unsigned long long l) { return catalytic_activity<microkatal, std::int64_t>(l); }
constexpr auto operator"" q_ukat(long double l) { return catalytic_activity<microkatal, long double>(l); } constexpr auto operator"" _q_ukat(long double l) { return catalytic_activity<microkatal, long double>(l); }
// mkat // mkat
constexpr auto operator"" q_mkat(unsigned long long l) { return catalytic_activity<millikatal, std::int64_t>(l); } constexpr auto operator"" _q_mkat(unsigned long long l) { return catalytic_activity<millikatal, std::int64_t>(l); }
constexpr auto operator"" q_mkat(long double l) { return catalytic_activity<millikatal, long double>(l); } constexpr auto operator"" _q_mkat(long double l) { return catalytic_activity<millikatal, long double>(l); }
// ckat // ckat
constexpr auto operator"" q_ckat(unsigned long long l) { return catalytic_activity<centikatal, std::int64_t>(l); } constexpr auto operator"" _q_ckat(unsigned long long l) { return catalytic_activity<centikatal, std::int64_t>(l); }
constexpr auto operator"" q_ckat(long double l) { return catalytic_activity<centikatal, long double>(l); } constexpr auto operator"" _q_ckat(long double l) { return catalytic_activity<centikatal, long double>(l); }
// dkat // dkat
constexpr auto operator"" q_dkat(unsigned long long l) { return catalytic_activity<decikatal, std::int64_t>(l); } constexpr auto operator"" _q_dkat(unsigned long long l) { return catalytic_activity<decikatal, std::int64_t>(l); }
constexpr auto operator"" q_dkat(long double l) { return catalytic_activity<decikatal, long double>(l); } constexpr auto operator"" _q_dkat(long double l) { return catalytic_activity<decikatal, long double>(l); }
// dakat // dakat
constexpr auto operator"" q_dakat(unsigned long long l) { return catalytic_activity<decakatal, std::int64_t>(l); } constexpr auto operator"" _q_dakat(unsigned long long l) { return catalytic_activity<decakatal, std::int64_t>(l); }
constexpr auto operator"" q_dakat(long double l) { return catalytic_activity<decakatal, long double>(l); } constexpr auto operator"" _q_dakat(long double l) { return catalytic_activity<decakatal, long double>(l); }
// hkat // hkat
constexpr auto operator"" q_hkat(unsigned long long l) { return catalytic_activity<hectokatal, std::int64_t>(l); } constexpr auto operator"" _q_hkat(unsigned long long l) { return catalytic_activity<hectokatal, std::int64_t>(l); }
constexpr auto operator"" q_hkat(long double l) { return catalytic_activity<hectokatal, long double>(l); } constexpr auto operator"" _q_hkat(long double l) { return catalytic_activity<hectokatal, long double>(l); }
// kkat // kkat
constexpr auto operator"" q_kkat(unsigned long long l) { return catalytic_activity<kilokatal, std::int64_t>(l); } constexpr auto operator"" _q_kkat(unsigned long long l) { return catalytic_activity<kilokatal, std::int64_t>(l); }
constexpr auto operator"" q_kkat(long double l) { return catalytic_activity<kilokatal, long double>(l); } constexpr auto operator"" _q_kkat(long double l) { return catalytic_activity<kilokatal, long double>(l); }
// Mkat // Mkat
constexpr auto operator"" q_Mkat(unsigned long long l) { return catalytic_activity<megakatal, std::int64_t>(l); } constexpr auto operator"" _q_Mkat(unsigned long long l) { return catalytic_activity<megakatal, std::int64_t>(l); }
constexpr auto operator"" q_Mkat(long double l) { return catalytic_activity<megakatal, long double>(l); } constexpr auto operator"" _q_Mkat(long double l) { return catalytic_activity<megakatal, long double>(l); }
// Gkat // Gkat
constexpr auto operator"" q_Gkat(unsigned long long l) { return catalytic_activity<gigakatal, std::int64_t>(l); } constexpr auto operator"" _q_Gkat(unsigned long long l) { return catalytic_activity<gigakatal, std::int64_t>(l); }
constexpr auto operator"" q_Gkat(long double l) { return catalytic_activity<gigakatal, long double>(l); } constexpr auto operator"" _q_Gkat(long double l) { return catalytic_activity<gigakatal, long double>(l); }
// Tkat // Tkat
constexpr auto operator"" q_Tkat(unsigned long long l) { return catalytic_activity<terakatal, std::int64_t>(l); } constexpr auto operator"" _q_Tkat(unsigned long long l) { return catalytic_activity<terakatal, std::int64_t>(l); }
constexpr auto operator"" q_Tkat(long double l) { return catalytic_activity<terakatal, long double>(l); } constexpr auto operator"" _q_Tkat(long double l) { return catalytic_activity<terakatal, long double>(l); }
// Pkat // Pkat
constexpr auto operator"" q_Pkat(unsigned long long l) { return catalytic_activity<petakatal, std::int64_t>(l); } constexpr auto operator"" _q_Pkat(unsigned long long l) { return catalytic_activity<petakatal, std::int64_t>(l); }
constexpr auto operator"" q_Pkat(long double l) { return catalytic_activity<petakatal, long double>(l); } constexpr auto operator"" _q_Pkat(long double l) { return catalytic_activity<petakatal, long double>(l); }
// Ekat // Ekat
constexpr auto operator"" q_Ekat(unsigned long long l) { return catalytic_activity<exakatal, std::int64_t>(l); } constexpr auto operator"" _q_Ekat(unsigned long long l) { return catalytic_activity<exakatal, std::int64_t>(l); }
constexpr auto operator"" q_Ekat(long double l) { return catalytic_activity<exakatal, long double>(l); } constexpr auto operator"" _q_Ekat(long double l) { return catalytic_activity<exakatal, long double>(l); }
// Zkat // Zkat
constexpr auto operator"" q_Zkat(unsigned long long l) { return catalytic_activity<zettakatal, std::int64_t>(l); } constexpr auto operator"" _q_Zkat(unsigned long long l) { return catalytic_activity<zettakatal, std::int64_t>(l); }
constexpr auto operator"" q_Zkat(long double l) { return catalytic_activity<zettakatal, long double>(l); } constexpr auto operator"" _q_Zkat(long double l) { return catalytic_activity<zettakatal, long double>(l); }
// Ykat // Ykat
constexpr auto operator"" q_Ykat(unsigned long long l) { return catalytic_activity<yottakatal, std::int64_t>(l); } constexpr auto operator"" _q_Ykat(unsigned long long l) { return catalytic_activity<yottakatal, std::int64_t>(l); }
constexpr auto operator"" q_Ykat(long double l) { return catalytic_activity<yottakatal, long double>(l); } constexpr auto operator"" _q_Ykat(long double l) { return catalytic_activity<yottakatal, long double>(l); }
// U // U
constexpr auto operator"" q_U(unsigned long long l) { return catalytic_activity<enzyme_unit, std::int64_t>(l); } constexpr auto operator"" _q_U(unsigned long long l) { return catalytic_activity<enzyme_unit, std::int64_t>(l); }
constexpr auto operator"" q_U(long double l) { return catalytic_activity<enzyme_unit, long double>(l); } constexpr auto operator"" _q_U(long double l) { return catalytic_activity<enzyme_unit, long double>(l); }
} // namespace literals } // namespace literals

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

@ -45,12 +45,12 @@ using surface_charge_density = quantity<dim_surface_charge_density, U, Rep>;
inline namespace literals { inline namespace literals {
// C/m³ // C/m³
constexpr auto operator"" q_C_per_m3(unsigned long long l) { return charge_density<coulomb_per_metre_cub, std::int64_t>(l); } constexpr auto operator"" _q_C_per_m3(unsigned long long l) { return charge_density<coulomb_per_metre_cub, std::int64_t>(l); }
constexpr auto operator"" q_C_per_m3(long double l) { return charge_density<coulomb_per_metre_cub, long double>(l); } constexpr auto operator"" _q_C_per_m3(long double l) { return charge_density<coulomb_per_metre_cub, long double>(l); }
// C/m² // C/m²
constexpr auto operator"" q_C_per_m2(unsigned long long l) { return surface_charge_density<coulomb_per_metre_sq, std::int64_t>(l); } constexpr auto operator"" _q_C_per_m2(unsigned long long l) { return surface_charge_density<coulomb_per_metre_sq, std::int64_t>(l); }
constexpr auto operator"" q_C_per_m2(long double l) { return surface_charge_density<coulomb_per_metre_sq, long double>(l); } constexpr auto operator"" _q_C_per_m2(long double l) { return surface_charge_density<coulomb_per_metre_sq, long double>(l); }
} // namespace literals } // namespace literals

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

@ -38,8 +38,8 @@ using concentration = quantity<dim_concentration, U, Rep>;
inline namespace literals { inline namespace literals {
// mol/m³ // mol/m³
constexpr auto operator"" q_mol_per_m3(unsigned long long l) { return concentration<mol_per_metre_cub, std::int64_t>(l); } constexpr auto operator"" _q_mol_per_m3(unsigned long long l) { return concentration<mol_per_metre_cub, std::int64_t>(l); }
constexpr auto operator"" q_mol_per_m3(long double l) { return concentration<mol_per_metre_cub, long double>(l); } constexpr auto operator"" _q_mol_per_m3(long double l) { return concentration<mol_per_metre_cub, long double>(l); }
} // namespace literals } // namespace literals

68
src/include/units/physical/si/conductance.h
View File

@ -55,72 +55,72 @@ using conductance = quantity<dim_conductance, U, Rep>;
inline namespace literals { inline namespace literals {
// R // R
constexpr auto operator"" q_S(unsigned long long l) { return conductance<siemens, std::int64_t>(l); } constexpr auto operator"" _q_S(unsigned long long l) { return conductance<siemens, std::int64_t>(l); }
constexpr auto operator"" q_S(long double l) { return conductance<siemens, long double>(l); } constexpr auto operator"" _q_S(long double l) { return conductance<siemens, long double>(l); }
// yS // yS
constexpr auto operator"" q_yS(unsigned long long l) { return conductance<yoctosiemens, std::int64_t>(l); } constexpr auto operator"" _q_yS(unsigned long long l) { return conductance<yoctosiemens, std::int64_t>(l); }
constexpr auto operator"" q_yS(long double l) { return conductance<yoctosiemens, long double>(l); } constexpr auto operator"" _q_yS(long double l) { return conductance<yoctosiemens, long double>(l); }
// zS // zS
constexpr auto operator"" q_zS(unsigned long long l) { return conductance<zeptosiemens, std::int64_t>(l); } constexpr auto operator"" _q_zS(unsigned long long l) { return conductance<zeptosiemens, std::int64_t>(l); }
constexpr auto operator"" q_zS(long double l) { return conductance<zeptosiemens, long double>(l); } constexpr auto operator"" _q_zS(long double l) { return conductance<zeptosiemens, long double>(l); }
// aS // aS
constexpr auto operator"" q_aS(unsigned long long l) { return conductance<attosiemens, std::int64_t>(l); } constexpr auto operator"" _q_aS(unsigned long long l) { return conductance<attosiemens, std::int64_t>(l); }
constexpr auto operator"" q_aS(long double l) { return conductance<attosiemens, long double>(l); } constexpr auto operator"" _q_aS(long double l) { return conductance<attosiemens, long double>(l); }
// fS // fS
constexpr auto operator"" q_fS(unsigned long long l) { return conductance<femtosiemens, std::int64_t>(l); } constexpr auto operator"" _q_fS(unsigned long long l) { return conductance<femtosiemens, std::int64_t>(l); }
constexpr auto operator"" q_fS(long double l) { return conductance<femtosiemens, long double>(l); } constexpr auto operator"" _q_fS(long double l) { return conductance<femtosiemens, long double>(l); }
// pS // pS
constexpr auto operator"" q_pS(unsigned long long l) { return conductance<picosiemens, std::int64_t>(l); } constexpr auto operator"" _q_pS(unsigned long long l) { return conductance<picosiemens, std::int64_t>(l); }
constexpr auto operator"" q_pS(long double l) { return conductance<picosiemens, long double>(l); } constexpr auto operator"" _q_pS(long double l) { return conductance<picosiemens, long double>(l); }
// nS // nS
constexpr auto operator"" q_nS(unsigned long long l) { return conductance<nanosiemens, std::int64_t>(l); } constexpr auto operator"" _q_nS(unsigned long long l) { return conductance<nanosiemens, std::int64_t>(l); }
constexpr auto operator"" q_nS(long double l) { return conductance<nanosiemens, long double>(l); } constexpr auto operator"" _q_nS(long double l) { return conductance<nanosiemens, long double>(l); }
// µS // µS
constexpr auto operator"" q_uS(unsigned long long l) { return conductance<microsiemens, std::int64_t>(l); } constexpr auto operator"" _q_uS(unsigned long long l) { return conductance<microsiemens, std::int64_t>(l); }
constexpr auto operator"" q_uS(long double l) { return conductance<microsiemens, long double>(l); } constexpr auto operator"" _q_uS(long double l) { return conductance<microsiemens, long double>(l); }
// mS // mS
constexpr auto operator"" q_mS(unsigned long long l) { return conductance<millisiemens, std::int64_t>(l); } constexpr auto operator"" _q_mS(unsigned long long l) { return conductance<millisiemens, std::int64_t>(l); }
constexpr auto operator"" q_mS(long double l) { return conductance<millisiemens, long double>(l); } constexpr auto operator"" _q_mS(long double l) { return conductance<millisiemens, long double>(l); }
// kS // kS
constexpr auto operator"" q_kS(unsigned long long l) { return conductance<kilosiemens, std::int64_t>(l); } constexpr auto operator"" _q_kS(unsigned long long l) { return conductance<kilosiemens, std::int64_t>(l); }
constexpr auto operator"" q_kS(long double l) { return conductance<kilosiemens, long double>(l); } constexpr auto operator"" _q_kS(long double l) { return conductance<kilosiemens, long double>(l); }
// MS // MS
constexpr auto operator"" q_MS(unsigned long long l) { return conductance<megasiemens, std::int64_t>(l); } constexpr auto operator"" _q_MS(unsigned long long l) { return conductance<megasiemens, std::int64_t>(l); }
constexpr auto operator"" q_MS(long double l) { return conductance<megasiemens, long double>(l); } constexpr auto operator"" _q_MS(long double l) { return conductance<megasiemens, long double>(l); }
// GS // GS
constexpr auto operator"" q_GS(unsigned long long l) { return conductance<gigasiemens, std::int64_t>(l); } constexpr auto operator"" _q_GS(unsigned long long l) { return conductance<gigasiemens, std::int64_t>(l); }
constexpr auto operator"" q_GS(long double l) { return conductance<gigasiemens, long double>(l); } constexpr auto operator"" _q_GS(long double l) { return conductance<gigasiemens, long double>(l); }
// TS // TS
constexpr auto operator"" q_TS(unsigned long long l) { return conductance<terasiemens, std::int64_t>(l); } constexpr auto operator"" _q_TS(unsigned long long l) { return conductance<terasiemens, std::int64_t>(l); }
constexpr auto operator"" q_TS(long double l) { return conductance<terasiemens, long double>(l); } constexpr auto operator"" _q_TS(long double l) { return conductance<terasiemens, long double>(l); }
// PS // PS
constexpr auto operator"" q_PS(unsigned long long l) { return conductance<petasiemens, std::int64_t>(l); } constexpr auto operator"" _q_PS(unsigned long long l) { return conductance<petasiemens, std::int64_t>(l); }
constexpr auto operator"" q_PS(long double l) { return conductance<petasiemens, long double>(l); } constexpr auto operator"" _q_PS(long double l) { return conductance<petasiemens, long double>(l); }
// ES // ES
constexpr auto operator"" q_ES(unsigned long long l) { return conductance<exasiemens, std::int64_t>(l); } constexpr auto operator"" _q_ES(unsigned long long l) { return conductance<exasiemens, std::int64_t>(l); }
constexpr auto operator"" q_ES(long double l) { return conductance<exasiemens, long double>(l); } constexpr auto operator"" _q_ES(long double l) { return conductance<exasiemens, long double>(l); }
// ZS // ZS
constexpr auto operator"" q_ZS(unsigned long long l) { return conductance<zettasiemens, std::int64_t>(l); } constexpr auto operator"" _q_ZS(unsigned long long l) { return conductance<zettasiemens, std::int64_t>(l); }
constexpr auto operator"" q_ZS(long double l) { return conductance<zettasiemens, long double>(l); } constexpr auto operator"" _q_ZS(long double l) { return conductance<zettasiemens, long double>(l); }
// YS // YS
constexpr auto operator"" q_YS(unsigned long long l) { return conductance<yottasiemens, std::int64_t>(l); } constexpr auto operator"" _q_YS(unsigned long long l) { return conductance<yottasiemens, std::int64_t>(l); }
constexpr auto operator"" q_YS(long double l) { return conductance<yottasiemens, long double>(l); } constexpr auto operator"" _q_YS(long double l) { return conductance<yottasiemens, long double>(l); }
} // namespace literals } // namespace literals

2
src/include/units/physical/si/constants.h
View File

@ -54,7 +54,7 @@ template<ScalableNumber Rep = double>
inline constexpr auto hyperfine_structure_transition_frequency = frequency<hertz, Rep>(9'192'631'770); inline constexpr auto hyperfine_structure_transition_frequency = frequency<hertz, Rep>(9'192'631'770);
// template<ScalableNumber Rep = double> // template<ScalableNumber Rep = double>
// inline constexpr auto luminous_efficacy = 683q_lm / 1q_W; // inline constexpr auto luminous_efficacy = 683_q_lm / 1_q_W;
template<ScalableNumber Rep = double> template<ScalableNumber Rep = double>
inline constexpr auto standard_gravity = acceleration<metre_per_second_sq, Rep>(9.80665); inline constexpr auto standard_gravity = acceleration<metre_per_second_sq, Rep>(9.80665);

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

@ -58,88 +58,88 @@ using current = quantity<dim_electric_current, U, Rep>;
inline namespace literals { inline namespace literals {
// A // A
constexpr auto operator"" q_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"" q_A(long double l) { return current<ampere, long double>(l); } constexpr auto operator"" _q_A(long double l) { return current<ampere, long double>(l); }
// yA // yA
constexpr auto operator"" q_yA(unsigned long long l) { return current<yoctoampere, std::int64_t>(l); } constexpr auto operator"" _q_yA(unsigned long long l) { return current<yoctoampere, std::int64_t>(l); }
constexpr auto operator"" q_yA(long double l) { return current<yoctoampere, long double>(l); } constexpr auto operator"" _q_yA(long double l) { return current<yoctoampere, long double>(l); }
// zA // zA
constexpr auto operator"" q_zA(unsigned long long l) { return current<zeptoampere, std::int64_t>(l); } constexpr auto operator"" _q_zA(unsigned long long l) { return current<zeptoampere, std::int64_t>(l); }
constexpr auto operator"" q_zA(long double l) { return current<zeptoampere, long double>(l); } constexpr auto operator"" _q_zA(long double l) { return current<zeptoampere, long double>(l); }
// aA // aA
constexpr auto operator"" q_aA(unsigned long long l) { return current<attoampere, std::int64_t>(l); } constexpr auto operator"" _q_aA(unsigned long long l) { return current<attoampere, std::int64_t>(l); }
constexpr auto operator"" q_aA(long double l) { return current<attoampere, long double>(l); } constexpr auto operator"" _q_aA(long double l) { return current<attoampere, long double>(l); }
// fA // fA
constexpr auto operator"" q_fA(unsigned long long l) { return current<femtoampere, std::int64_t>(l); } constexpr auto operator"" _q_fA(unsigned long long l) { return current<femtoampere, std::int64_t>(l); }
constexpr auto operator"" q_fA(long double l) { return current<femtoampere, long double>(l); } constexpr auto operator"" _q_fA(long double l) { return current<femtoampere, long double>(l); }
// pA // pA
constexpr auto operator"" q_pA(unsigned long long l) { return current<picoampere, std::int64_t>(l); } constexpr auto operator"" _q_pA(unsigned long long l) { return current<picoampere, std::int64_t>(l); }
constexpr auto operator"" q_pA(long double l) { return current<picoampere, long double>(l); } constexpr auto operator"" _q_pA(long double l) { return current<picoampere, long double>(l); }
// nA // nA
constexpr auto operator"" q_nA(unsigned long long l) { return current<nanoampere, std::int64_t>(l); } constexpr auto operator"" _q_nA(unsigned long long l) { return current<nanoampere, std::int64_t>(l); }
constexpr auto operator"" q_nA(long double l) { return current<nanoampere, long double>(l); } constexpr auto operator"" _q_nA(long double l) { return current<nanoampere, long double>(l); }
// uA // uA
constexpr auto operator"" q_uA(unsigned long long l) { return current<microampere, std::int64_t>(l); } constexpr auto operator"" _q_uA(unsigned long long l) { return current<microampere, std::int64_t>(l); }
constexpr auto operator"" q_uA(long double l) { return current<microampere, long double>(l); } constexpr auto operator"" _q_uA(long double l) { return current<microampere, long double>(l); }
// mA // mA
constexpr auto operator"" q_mA(unsigned long long l) { return current<milliampere, std::int64_t>(l); } constexpr auto operator"" _q_mA(unsigned long long l) { return current<milliampere, std::int64_t>(l); }
constexpr auto operator"" q_mA(long double l) { return current<milliampere, long double>(l); } constexpr auto operator"" _q_mA(long double l) { return current<milliampere, long double>(l); }
// cA // cA
constexpr auto operator"" q_cA(unsigned long long l) { return current<centiampere, std::int64_t>(l); } constexpr auto operator"" _q_cA(unsigned long long l) { return current<centiampere, std::int64_t>(l); }
constexpr auto operator"" q_cA(long double l) { return current<centiampere, long double>(l); } constexpr auto operator"" _q_cA(long double l) { return current<centiampere, long double>(l); }
// dA // dA
constexpr auto operator"" q_dA(unsigned long long l) { return current<deciampere, std::int64_t>(l); } constexpr auto operator"" _q_dA(unsigned long long l) { return current<deciampere, std::int64_t>(l); }
constexpr auto operator"" q_dA(long double l) { return current<deciampere, long double>(l); } constexpr auto operator"" _q_dA(long double l) { return current<deciampere, long double>(l); }
// daA // daA
constexpr auto operator"" q_daA(unsigned long long l) { return current<decaampere, std::int64_t>(l); } constexpr auto operator"" _q_daA(unsigned long long l) { return current<decaampere, std::int64_t>(l); }
constexpr auto operator"" q_daA(long double l) { return current<decaampere, long double>(l); } constexpr auto operator"" _q_daA(long double l) { return current<decaampere, long double>(l); }
// hA // hA
constexpr auto operator"" q_hA(unsigned long long l) { return current<hectoampere, std::int64_t>(l); } constexpr auto operator"" _q_hA(unsigned long long l) { return current<hectoampere, std::int64_t>(l); }
constexpr auto operator"" q_hA(long double l) { return current<hectoampere, long double>(l); } constexpr auto operator"" _q_hA(long double l) { return current<hectoampere, long double>(l); }
// kA // kA
constexpr auto operator"" q_kA(unsigned long long l) { return current<kiloampere, std::int64_t>(l); } constexpr auto operator"" _q_kA(unsigned long long l) { return current<kiloampere, std::int64_t>(l); }
constexpr auto operator"" q_kA(long double l) { return current<kiloampere, long double>(l); } constexpr auto operator"" _q_kA(long double l) { return current<kiloampere, long double>(l); }
// MA // MA
constexpr auto operator"" q_MA(unsigned long long l) { return current<megaampere, std::int64_t>(l); } constexpr auto operator"" _q_MA(unsigned long long l) { return current<megaampere, std::int64_t>(l); }
constexpr auto operator"" q_MA(long double l) { return current<megaampere, long double>(l); } constexpr auto operator"" _q_MA(long double l) { return current<megaampere, long double>(l); }
// GA // GA
constexpr auto operator"" q_GA(unsigned long long l) { return current<gigaampere, std::int64_t>(l); } constexpr auto operator"" _q_GA(unsigned long long l) { return current<gigaampere, std::int64_t>(l); }
constexpr auto operator"" q_GA(long double l) { return current<gigaampere, long double>(l); } constexpr auto operator"" _q_GA(long double l) { return current<gigaampere, long double>(l); }
// TA // TA
constexpr auto operator"" q_TA(unsigned long long l) { return current<teraampere, std::int64_t>(l); } constexpr auto operator"" _q_TA(unsigned long long l) { return current<teraampere, std::int64_t>(l); }
constexpr auto operator"" q_TA(long double l) { return current<teraampere, long double>(l); } constexpr auto operator"" _q_TA(long double l) { return current<teraampere, long double>(l); }
// PA // PA
constexpr auto operator"" q_PA(unsigned long long l) { return current<petaampere, std::int64_t>(l); } constexpr auto operator"" _q_PA(unsigned long long l) { return current<petaampere, std::int64_t>(l); }
constexpr auto operator"" q_PA(long double l) { return current<petaampere, long double>(l); } constexpr auto operator"" _q_PA(long double l) { return current<petaampere, long double>(l); }
// EA // EA
constexpr auto operator"" q_EA(unsigned long long l) { return current<exaampere, std::int64_t>(l); } constexpr auto operator"" _q_EA(unsigned long long l) { return current<exaampere, std::int64_t>(l); }
constexpr auto operator"" q_EA(long double l) { return current<exaampere, long double>(l); } constexpr auto operator"" _q_EA(long double l) { return current<exaampere, long double>(l); }
// ZA // ZA
constexpr auto operator"" q_ZA(unsigned long long l) { return current<zettaampere, std::int64_t>(l); } constexpr auto operator"" _q_ZA(unsigned long long l) { return current<zettaampere, std::int64_t>(l); }
constexpr auto operator"" q_ZA(long double l) { return current<zettaampere, long double>(l); } constexpr auto operator"" _q_ZA(long double l) { return current<zettaampere, long double>(l); }
// YA // YA
constexpr auto operator"" q_YA(unsigned long long l) { return current<yottaampere, std::int64_t>(l); } constexpr auto operator"" _q_YA(unsigned long long l) { return current<yottaampere, std::int64_t>(l); }
constexpr auto operator"" q_YA(long double l) { return current<yottaampere, long double>(l); } constexpr auto operator"" _q_YA(long double l) { return current<yottaampere, long double>(l); }
} // namespace literals } // namespace literals

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

@ -39,8 +39,8 @@ using current_density = quantity<dim_current_density, U, Rep>;
inline namespace literals { inline namespace literals {
constexpr auto operator"" q_A_per_m2(unsigned long long l) { return current_density<ampere_per_metre_sq, std::int64_t>(l); } constexpr auto operator"" _q_A_per_m2(unsigned long long l) { return current_density<ampere_per_metre_sq, std::int64_t>(l); }
constexpr auto operator"" q_A_per_m2(long double l) { return current_density<ampere_per_metre_sq, long double>(l); } constexpr auto operator"" _q_A_per_m2(long double l) { return current_density<ampere_per_metre_sq, 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"" q_kg_per_m3(unsigned long long l) { return density<kilogram_per_metre_cub, std::int64_t>(l); } constexpr auto operator"" _q_kg_per_m3(unsigned long long l) { return density<kilogram_per_metre_cub, std::int64_t>(l); }
constexpr auto operator"" q_kg_per_m3(long double l) { return density<kilogram_per_metre_cub, long double>(l); } constexpr auto operator"" _q_kg_per_m3(long double l) { return density<kilogram_per_metre_cub, long double>(l); }
} // namespace literals } // namespace literals

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

@ -38,8 +38,8 @@ using dynamic_viscosity = quantity<dim_dynamic_viscosity, U, Rep>;
inline namespace literals { inline namespace literals {
// Pa·s // Pa·s
constexpr auto operator"" q_Pa_s(unsigned long long l) { return dynamic_viscosity<pascal_second, std::int64_t>(l); } constexpr auto operator"" _q_Pa_s(unsigned long long l) { return dynamic_viscosity<pascal_second, std::int64_t>(l); }
constexpr auto operator"" q_Pa_s(long double l) { return dynamic_viscosity<pascal_second, long double>(l); } constexpr auto operator"" _q_Pa_s(long double l) { return dynamic_viscosity<pascal_second, 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"" q_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"" q_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

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

@ -37,8 +37,8 @@ using electric_field_strength = quantity<dim_electric_field_strength, U, Rep>;
inline namespace literals { inline namespace literals {
// V/m // V/m
constexpr auto operator"" q_V_per_m(unsigned long long l) { return electric_field_strength<volt_per_metre, std::int64_t>(l); } constexpr auto operator"" _q_V_per_m(unsigned long long l) { return electric_field_strength<volt_per_metre, std::int64_t>(l); }
constexpr auto operator"" q_V_per_m(long double l) { return electric_field_strength<volt_per_metre, long double>(l); } constexpr auto operator"" _q_V_per_m(long double l) { return electric_field_strength<volt_per_metre, long double>(l); }
} // namespace literals } // namespace literals

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

@ -58,80 +58,80 @@ using energy = quantity<dim_energy, U, Rep>;
inline namespace literals { inline namespace literals {
// J // J
constexpr auto operator"" q_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"" q_J(long double l) { return energy<joule, long double>(l); } constexpr auto operator"" _q_J(long double l) { return energy<joule, long double>(l); }
// yJ // yJ
constexpr auto operator"" q_yJ(unsigned long long l) { return energy<yoctojoule, std::int64_t>(l); } constexpr auto operator"" _q_yJ(unsigned long long l) { return energy<yoctojoule, std::int64_t>(l); }
constexpr auto operator"" q_yJ(long double l) { return energy<yoctojoule, long double>(l); } constexpr auto operator"" _q_yJ(long double l) { return energy<yoctojoule, long double>(l); }
// zJ // zJ
constexpr auto operator"" q_zJ(unsigned long long l) { return energy<zeptojoule, std::int64_t>(l); } constexpr auto operator"" _q_zJ(unsigned long long l) { return energy<zeptojoule, std::int64_t>(l); }
constexpr auto operator"" q_zJ(long double l) { return energy<zeptojoule, long double>(l); } constexpr auto operator"" _q_zJ(long double l) { return energy<zeptojoule, long double>(l); }
// aJ // aJ
constexpr auto operator"" q_aJ(unsigned long long l) { return energy<attojoule, std::int64_t>(l); } constexpr auto operator"" _q_aJ(unsigned long long l) { return energy<attojoule, std::int64_t>(l); }
constexpr auto operator"" q_aJ(long double l) { return energy<attojoule, long double>(l); } constexpr auto operator"" _q_aJ(long double l) { return energy<attojoule, long double>(l); }
// fJ // fJ
constexpr auto operator"" q_fJ(unsigned long long l) { return energy<femtojoule, std::int64_t>(l); } constexpr auto operator"" _q_fJ(unsigned long long l) { return energy<femtojoule, std::int64_t>(l); }
constexpr auto operator"" q_fJ(long double l) { return energy<femtojoule, long double>(l); } constexpr auto operator"" _q_fJ(long double l) { return energy<femtojoule, long double>(l); }
// pJ // pJ
constexpr auto operator"" q_pJ(unsigned long long l) { return energy<picojoule, std::int64_t>(l); } constexpr auto operator"" _q_pJ(unsigned long long l) { return energy<picojoule, std::int64_t>(l); }
constexpr auto operator"" q_pJ(long double l) { return energy<picojoule, long double>(l); } constexpr auto operator"" _q_pJ(long double l) { return energy<picojoule, long double>(l); }
// nJ // nJ
constexpr auto operator"" q_nJ(unsigned long long l) { return energy<nanojoule, std::int64_t>(l); } constexpr auto operator"" _q_nJ(unsigned long long l) { return energy<nanojoule, std::int64_t>(l); }
constexpr auto operator"" q_nJ(long double l) { return energy<nanojoule, long double>(l); } constexpr auto operator"" _q_nJ(long double l) { return energy<nanojoule, long double>(l); }
// uJ // uJ
constexpr auto operator"" q_uJ(unsigned long long l) { return energy<microjoule, std::int64_t>(l); } constexpr auto operator"" _q_uJ(unsigned long long l) { return energy<microjoule, std::int64_t>(l); }
constexpr auto operator"" q_uJ(long double l) { return energy<microjoule, long double>(l); } constexpr auto operator"" _q_uJ(long double l) { return energy<microjoule, long double>(l); }
// mJ // mJ
constexpr auto operator"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_GJ(long double l) { return energy<gigajoule, long double>(l); } constexpr auto operator"" _q_GJ(long double l) { return energy<gigajoule, long double>(l); }
// TJ // TJ
constexpr auto operator"" q_TJ(unsigned long long l) { return energy<terajoule, std::int64_t>(l); } constexpr auto operator"" _q_TJ(unsigned long long l) { return energy<terajoule, std::int64_t>(l); }
constexpr auto operator"" q_TJ(long double l) { return energy<terajoule, long double>(l); } constexpr auto operator"" _q_TJ(long double l) { return energy<terajoule, long double>(l); }
// PJ // PJ
constexpr auto operator"" q_PJ(unsigned long long l) { return energy<petajoule, std::int64_t>(l); } constexpr auto operator"" _q_PJ(unsigned long long l) { return energy<petajoule, std::int64_t>(l); }
constexpr auto operator"" q_PJ(long double l) { return energy<petajoule, long double>(l); } constexpr auto operator"" _q_PJ(long double l) { return energy<petajoule, long double>(l); }
// EJ // EJ
constexpr auto operator"" q_EJ(unsigned long long l) { return energy<exajoule, std::int64_t>(l); } constexpr auto operator"" _q_EJ(unsigned long long l) { return energy<exajoule, std::int64_t>(l); }
constexpr auto operator"" q_EJ(long double l) { return energy<exajoule, long double>(l); } constexpr auto operator"" _q_EJ(long double l) { return energy<exajoule, long double>(l); }
// ZJ // ZJ
constexpr auto operator"" q_ZJ(unsigned long long l) { return energy<zettajoule, std::int64_t>(l); } constexpr auto operator"" _q_ZJ(unsigned long long l) { return energy<zettajoule, std::int64_t>(l); }
constexpr auto operator"" q_ZJ(long double l) { return energy<zettajoule, long double>(l); } constexpr auto operator"" _q_ZJ(long double l) { return energy<zettajoule, long double>(l); }
// YJ // YJ
constexpr auto operator"" q_YJ(unsigned long long l) { return energy<yottajoule, std::int64_t>(l); } constexpr auto operator"" _q_YJ(unsigned long long l) { return energy<yottajoule, std::int64_t>(l); }
constexpr auto operator"" q_YJ(long double l) { return energy<yottajoule, long double>(l); } constexpr auto operator"" _q_YJ(long double l) { return energy<yottajoule, long double>(l); }
// eV // eV
constexpr auto operator"" q_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"" q_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"" q_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"" q_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

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

@ -60,88 +60,88 @@ using force = quantity<dim_force, U, Rep>;
inline namespace literals { inline namespace literals {
// N // N
constexpr auto operator"" q_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"" q_N(long double l) { return force<newton, long double>(l); } constexpr auto operator"" _q_N(long double l) { return force<newton, long double>(l); }
// yN // yN
constexpr auto operator"" q_yN(unsigned long long l) { return force<yoctonewton, std::int64_t>(l); } constexpr auto operator"" _q_yN(unsigned long long l) { return force<yoctonewton, std::int64_t>(l); }
constexpr auto operator"" q_yN(long double l) { return force<yoctonewton, long double>(l); } constexpr auto operator"" _q_yN(long double l) { return force<yoctonewton, long double>(l); }
// zN // zN
constexpr auto operator"" q_zN(unsigned long long l) { return force<zeptonewton, std::int64_t>(l); } constexpr auto operator"" _q_zN(unsigned long long l) { return force<zeptonewton, std::int64_t>(l); }
constexpr auto operator"" q_zN(long double l) { return force<zeptonewton, long double>(l); } constexpr auto operator"" _q_zN(long double l) { return force<zeptonewton, long double>(l); }
// aN // aN
constexpr auto operator"" q_aN(unsigned long long l) { return force<attonewton, std::int64_t>(l); } constexpr auto operator"" _q_aN(unsigned long long l) { return force<attonewton, std::int64_t>(l); }
constexpr auto operator"" q_aN(long double l) { return force<attonewton, long double>(l); } constexpr auto operator"" _q_aN(long double l) { return force<attonewton, long double>(l); }
// fN // fN
constexpr auto operator"" q_fN(unsigned long long l) { return force<femtonewton, std::int64_t>(l); } constexpr auto operator"" _q_fN(unsigned long long l) { return force<femtonewton, std::int64_t>(l); }
constexpr auto operator"" q_fN(long double l) { return force<femtonewton, long double>(l); } constexpr auto operator"" _q_fN(long double l) { return force<femtonewton, long double>(l); }
// pN // pN
constexpr auto operator"" q_pN(unsigned long long l) { return force<piconewton, std::int64_t>(l); } constexpr auto operator"" _q_pN(unsigned long long l) { return force<piconewton, std::int64_t>(l); }
constexpr auto operator"" q_pN(long double l) { return force<piconewton, long double>(l); } constexpr auto operator"" _q_pN(long double l) { return force<piconewton, long double>(l); }
// nN // nN
constexpr auto operator"" q_nN(unsigned long long l) { return force<nanonewton, std::int64_t>(l); } constexpr auto operator"" _q_nN(unsigned long long l) { return force<nanonewton, std::int64_t>(l); }
constexpr auto operator"" q_nN(long double l) { return force<nanonewton, long double>(l); } constexpr auto operator"" _q_nN(long double l) { return force<nanonewton, long double>(l); }
// uN // uN
constexpr auto operator"" q_uN(unsigned long long l) { return force<micronewton, std::int64_t>(l); } constexpr auto operator"" _q_uN(unsigned long long l) { return force<micronewton, std::int64_t>(l); }
constexpr auto operator"" q_uN(long double l) { return force<micronewton, long double>(l); } constexpr auto operator"" _q_uN(long double l) { return force<micronewton, long double>(l); }
// mN // mN
constexpr auto operator"" q_mN(unsigned long long l) { return force<millinewton, std::int64_t>(l); } constexpr auto operator"" _q_mN(unsigned long long l) { return force<millinewton, std::int64_t>(l); }
constexpr auto operator"" q_mN(long double l) { return force<millinewton, long double>(l); } constexpr auto operator"" _q_mN(long double l) { return force<millinewton, long double>(l); }
// cN // cN
constexpr auto operator"" q_cN(unsigned long long l) { return force<centinewton, std::int64_t>(l); } constexpr auto operator"" _q_cN(unsigned long long l) { return force<centinewton, std::int64_t>(l); }
constexpr auto operator"" q_cN(long double l) { return force<centinewton, long double>(l); } constexpr auto operator"" _q_cN(long double l) { return force<centinewton, long double>(l); }
// dN // dN
constexpr auto operator"" q_dN(unsigned long long l) { return force<decinewton, std::int64_t>(l); } constexpr auto operator"" _q_dN(unsigned long long l) { return force<decinewton, std::int64_t>(l); }
constexpr auto operator"" q_dN(long double l) { return force<decinewton, long double>(l); } constexpr auto operator"" _q_dN(long double l) { return force<decinewton, long double>(l); }
// daN // daN
constexpr auto operator"" q_daN(unsigned long long l) { return force<decanewton, std::int64_t>(l); } constexpr auto operator"" _q_daN(unsigned long long l) { return force<decanewton, std::int64_t>(l); }
constexpr auto operator"" q_daN(long double l) { return force<decanewton, long double>(l); } constexpr auto operator"" _q_daN(long double l) { return force<decanewton, long double>(l); }
// hN // hN
constexpr auto operator"" q_hN(unsigned long long l) { return force<hectonewton, std::int64_t>(l); } constexpr auto operator"" _q_hN(unsigned long long l) { return force<hectonewton, std::int64_t>(l); }
constexpr auto operator"" q_hN(long double l) { return force<hectonewton, long double>(l); } constexpr auto operator"" _q_hN(long double l) { return force<hectonewton, long double>(l); }
// kN // kN
constexpr auto operator"" q_kN(unsigned long long l) { return force<kilonewton, std::int64_t>(l); } constexpr auto operator"" _q_kN(unsigned long long l) { return force<kilonewton, std::int64_t>(l); }
constexpr auto operator"" q_kN(long double l) { return force<kilonewton, long double>(l); } constexpr auto operator"" _q_kN(long double l) { return force<kilonewton, long double>(l); }
// MN // MN
constexpr auto operator"" q_MN(unsigned long long l) { return force<meganewton, std::int64_t>(l); } constexpr auto operator"" _q_MN(unsigned long long l) { return force<meganewton, std::int64_t>(l); }
constexpr auto operator"" q_MN(long double l) { return force<meganewton, long double>(l); } constexpr auto operator"" _q_MN(long double l) { return force<meganewton, long double>(l); }
// GN // GN
constexpr auto operator"" q_GN(unsigned long long l) { return force<giganewton, std::int64_t>(l); } constexpr auto operator"" _q_GN(unsigned long long l) { return force<giganewton, std::int64_t>(l); }
constexpr auto operator"" q_GN(long double l) { return force<giganewton, long double>(l); } constexpr auto operator"" _q_GN(long double l) { return force<giganewton, long double>(l); }
// TN // TN
constexpr auto operator"" q_TN(unsigned long long l) { return force<teranewton, std::int64_t>(l); } constexpr auto operator"" _q_TN(unsigned long long l) { return force<teranewton, std::int64_t>(l); }
constexpr auto operator"" q_TN(long double l) { return force<teranewton, long double>(l); } constexpr auto operator"" _q_TN(long double l) { return force<teranewton, long double>(l); }
// PN // PN
constexpr auto operator"" q_PN(unsigned long long l) { return force<petanewton, std::int64_t>(l); } constexpr auto operator"" _q_PN(unsigned long long l) { return force<petanewton, std::int64_t>(l); }
constexpr auto operator"" q_PN(long double l) { return force<petanewton, long double>(l); } constexpr auto operator"" _q_PN(long double l) { return force<petanewton, long double>(l); }
// EN // EN
constexpr auto operator"" q_EN(unsigned long long l) { return force<exanewton, std::int64_t>(l); } constexpr auto operator"" _q_EN(unsigned long long l) { return force<exanewton, std::int64_t>(l); }
constexpr auto operator"" q_EN(long double l) { return force<exanewton, long double>(l); } constexpr auto operator"" _q_EN(long double l) { return force<exanewton, long double>(l); }
// ZN // ZN
constexpr auto operator"" q_ZN(unsigned long long l) { return force<zettanewton, std::int64_t>(l); } constexpr auto operator"" _q_ZN(unsigned long long l) { return force<zettanewton, std::int64_t>(l); }
constexpr auto operator"" q_ZN(long double l) { return force<zettanewton, long double>(l); } constexpr auto operator"" _q_ZN(long double l) { return force<zettanewton, long double>(l); }
// YN // YN
constexpr auto operator"" q_YN(unsigned long long l) { return force<yottanewton, std::int64_t>(l); } constexpr auto operator"" _q_YN(unsigned long long l) { return force<yottanewton, std::int64_t>(l); }
constexpr auto operator"" q_YN(long double l) { return force<yottanewton, long double>(l); } constexpr auto operator"" _q_YN(long double l) { return force<yottanewton, long double>(l); }
} // namespace literals } // namespace literals

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

@ -54,72 +54,72 @@ using frequency = quantity<dim_frequency, U, Rep>;
inline namespace literals { inline namespace literals {
// Hz // Hz
constexpr auto operator"" q_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"" q_Hz(long double l) { return frequency<hertz, long double>(l); } constexpr auto operator"" _q_Hz(long double l) { return frequency<hertz, long double>(l); }
// yHz // yHz
constexpr auto operator"" q_yHz(unsigned long long l) { return frequency<yoctohertz, std::int64_t>(l); } constexpr auto operator"" _q_yHz(unsigned long long l) { return frequency<yoctohertz, std::int64_t>(l); }
constexpr auto operator"" q_yHz(long double l) { return frequency<yoctohertz, long double>(l); } constexpr auto operator"" _q_yHz(long double l) { return frequency<yoctohertz, long double>(l); }
// zHz // zHz
constexpr auto operator"" q_zHz(unsigned long long l) { return frequency<zeptohertz, std::int64_t>(l); } constexpr auto operator"" _q_zHz(unsigned long long l) { return frequency<zeptohertz, std::int64_t>(l); }
constexpr auto operator"" q_zHz(long double l) { return frequency<zeptohertz, long double>(l); } constexpr auto operator"" _q_zHz(long double l) { return frequency<zeptohertz, long double>(l); }
// aHz // aHz
constexpr auto operator"" q_aHz(unsigned long long l) { return frequency<attohertz, std::int64_t>(l); } constexpr auto operator"" _q_aHz(unsigned long long l) { return frequency<attohertz, std::int64_t>(l); }
constexpr auto operator"" q_aHz(long double l) { return frequency<attohertz, long double>(l); } constexpr auto operator"" _q_aHz(long double l) { return frequency<attohertz, long double>(l); }
// fHz // fHz
constexpr auto operator"" q_fHz(unsigned long long l) { return frequency<femtohertz, std::int64_t>(l); } constexpr auto operator"" _q_fHz(unsigned long long l) { return frequency<femtohertz, std::int64_t>(l); }
constexpr auto operator"" q_fHz(long double l) { return frequency<femtohertz, long double>(l); } constexpr auto operator"" _q_fHz(long double l) { return frequency<femtohertz, long double>(l); }
// pHz // pHz
constexpr auto operator"" q_pHz(unsigned long long l) { return frequency<picohertz, std::int64_t>(l); } constexpr auto operator"" _q_pHz(unsigned long long l) { return frequency<picohertz, std::int64_t>(l); }
constexpr auto operator"" q_pHz(long double l) { return frequency<picohertz, long double>(l); } constexpr auto operator"" _q_pHz(long double l) { return frequency<picohertz, long double>(l); }
// nHz // nHz
constexpr auto operator"" q_nHz(unsigned long long l) { return frequency<nanohertz, std::int64_t>(l); } constexpr auto operator"" _q_nHz(unsigned long long l) { return frequency<nanohertz, std::int64_t>(l); }
constexpr auto operator"" q_nHz(long double l) { return frequency<nanohertz, long double>(l); } constexpr auto operator"" _q_nHz(long double l) { return frequency<nanohertz, long double>(l); }
// uHz // uHz
constexpr auto operator"" q_uHz(unsigned long long l) { return frequency<microhertz, std::int64_t>(l); } constexpr auto operator"" _q_uHz(unsigned long long l) { return frequency<microhertz, std::int64_t>(l); }
constexpr auto operator"" q_uHz(long double l) { return frequency<microhertz, long double>(l); } constexpr auto operator"" _q_uHz(long double l) { return frequency<microhertz, long double>(l); }
// mHz // mHz
constexpr auto operator"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_THz(long double l) { return frequency<terahertz, long double>(l); } constexpr auto operator"" _q_THz(long double l) { return frequency<terahertz, long double>(l); }
// PHz // PHz
constexpr auto operator"" q_PHz(unsigned long long l) { return frequency<petahertz, std::int64_t>(l); } constexpr auto operator"" _q_PHz(unsigned long long l) { return frequency<petahertz, std::int64_t>(l); }
constexpr auto operator"" q_PHz(long double l) { return frequency<petahertz, long double>(l); } constexpr auto operator"" _q_PHz(long double l) { return frequency<petahertz, long double>(l); }
// EHz // EHz
constexpr auto operator"" q_EHz(unsigned long long l) { return frequency<exahertz, std::int64_t>(l); } constexpr auto operator"" _q_EHz(unsigned long long l) { return frequency<exahertz, std::int64_t>(l); }
constexpr auto operator"" q_EHz(long double l) { return frequency<exahertz, long double>(l); } constexpr auto operator"" _q_EHz(long double l) { return frequency<exahertz, long double>(l); }
// ZHz // ZHz
constexpr auto operator"" q_ZHz(unsigned long long l) { return frequency<zettahertz, std::int64_t>(l); } constexpr auto operator"" _q_ZHz(unsigned long long l) { return frequency<zettahertz, std::int64_t>(l); }
constexpr auto operator"" q_ZHz(long double l) { return frequency<zettahertz, long double>(l); } constexpr auto operator"" _q_ZHz(long double l) { return frequency<zettahertz, long double>(l); }
// YHz // YHz
constexpr auto operator"" q_YHz(unsigned long long l) { return frequency<yottahertz, std::int64_t>(l); } constexpr auto operator"" _q_YHz(unsigned long long l) { return frequency<yottahertz, std::int64_t>(l); }
constexpr auto operator"" q_YHz(long double l) { return frequency<yottahertz, long double>(l); } constexpr auto operator"" _q_YHz(long double l) { return frequency<yottahertz, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/si/heat_capacity.h
View File

@ -51,16 +51,16 @@ using molar_heat_capacity = quantity<dim_molar_heat_capacity, U, Rep>;
inline namespace literals { inline namespace literals {
// J/K // J/K
constexpr auto operator"" q_J_per_K(unsigned long long l) { return heat_capacity<joule_per_kelvin, std::int64_t>(l); } constexpr auto operator"" _q_J_per_K(unsigned long long l) { return heat_capacity<joule_per_kelvin, std::int64_t>(l); }
constexpr auto operator"" q_J_per_K(long double l) { return heat_capacity<joule_per_kelvin, long double>(l); } constexpr auto operator"" _q_J_per_K(long double l) { return heat_capacity<joule_per_kelvin, long double>(l); }
// J/(kg·K) // J/(kg·K)
constexpr auto operator"" q_J_per_kg_K(unsigned long long l) { return specific_heat_capacity<joule_per_kilogram_kelvin, std::int64_t>(l); } constexpr auto operator"" _q_J_per_kg_K(unsigned long long l) { return specific_heat_capacity<joule_per_kilogram_kelvin, std::int64_t>(l); }
constexpr auto operator"" q_J_per_kg_K(long double l) { return specific_heat_capacity<joule_per_kilogram_kelvin, long double>(l); } constexpr auto operator"" _q_J_per_kg_K(long double l) { return specific_heat_capacity<joule_per_kilogram_kelvin, long double>(l); }
// J/(mol·K) // J/(mol·K)
constexpr auto operator"" q_J_per_mol_K(unsigned long long l) { return molar_heat_capacity<joule_per_mole_kelvin, std::int64_t>(l); } constexpr auto operator"" _q_J_per_mol_K(unsigned long long l) { return molar_heat_capacity<joule_per_mole_kelvin, std::int64_t>(l); }
constexpr auto operator"" q_J_per_mol_K(long double l) { return molar_heat_capacity<joule_per_mole_kelvin, long double>(l); } constexpr auto operator"" _q_J_per_mol_K(long double l) { return molar_heat_capacity<joule_per_mole_kelvin, long double>(l); }
} // namespace literals } // namespace literals

68
src/include/units/physical/si/inductance.h
View File

@ -56,72 +56,72 @@ using inductance = quantity<dim_inductance, U, Rep>;
inline namespace literals { inline namespace literals {
// H // H
constexpr auto operator"" q_H(unsigned long long l) { return inductance<henry, std::int64_t>(l); } constexpr auto operator"" _q_H(unsigned long long l) { return inductance<henry, std::int64_t>(l); }
constexpr auto operator"" q_H(long double l) { return inductance<henry, long double>(l); } constexpr auto operator"" _q_H(long double l) { return inductance<henry, long double>(l); }
// yH // yH
constexpr auto operator"" q_yH(unsigned long long l) { return inductance<yoctohenry, std::int64_t>(l); } constexpr auto operator"" _q_yH(unsigned long long l) { return inductance<yoctohenry, std::int64_t>(l); }
constexpr auto operator"" q_yH(long double l) { return inductance<yoctohenry, long double>(l); } constexpr auto operator"" _q_yH(long double l) { return inductance<yoctohenry, long double>(l); }
// zH // zH
constexpr auto operator"" q_zH(unsigned long long l) { return inductance<zeptohenry, std::int64_t>(l); } constexpr auto operator"" _q_zH(unsigned long long l) { return inductance<zeptohenry, std::int64_t>(l); }
constexpr auto operator"" q_zH(long double l) { return inductance<zeptohenry, long double>(l); } constexpr auto operator"" _q_zH(long double l) { return inductance<zeptohenry, long double>(l); }
// aH // aH
constexpr auto operator"" q_aH(unsigned long long l) { return inductance<attohenry, std::int64_t>(l); } constexpr auto operator"" _q_aH(unsigned long long l) { return inductance<attohenry, std::int64_t>(l); }
constexpr auto operator"" q_aH(long double l) { return inductance<attohenry, long double>(l); } constexpr auto operator"" _q_aH(long double l) { return inductance<attohenry, long double>(l); }
// fH // fH
constexpr auto operator"" q_fH(unsigned long long l) { return inductance<femtohenry, std::int64_t>(l); } constexpr auto operator"" _q_fH(unsigned long long l) { return inductance<femtohenry, std::int64_t>(l); }
constexpr auto operator"" q_fH(long double l) { return inductance<femtohenry, long double>(l); } constexpr auto operator"" _q_fH(long double l) { return inductance<femtohenry, long double>(l); }
// pH // pH
constexpr auto operator"" q_pH(unsigned long long l) { return inductance<picohenry, std::int64_t>(l); } constexpr auto operator"" _q_pH(unsigned long long l) { return inductance<picohenry, std::int64_t>(l); }
constexpr auto operator"" q_pH(long double l) { return inductance<picohenry, long double>(l); } constexpr auto operator"" _q_pH(long double l) { return inductance<picohenry, long double>(l); }
// nH // nH
constexpr auto operator"" q_nH(unsigned long long l) { return inductance<nanohenry, std::int64_t>(l); } constexpr auto operator"" _q_nH(unsigned long long l) { return inductance<nanohenry, std::int64_t>(l); }
constexpr auto operator"" q_nH(long double l) { return inductance<nanohenry, long double>(l); } constexpr auto operator"" _q_nH(long double l) { return inductance<nanohenry, long double>(l); }
// µH // µH
constexpr auto operator"" q_uH(unsigned long long l) { return inductance<microhenry, std::int64_t>(l); } constexpr auto operator"" _q_uH(unsigned long long l) { return inductance<microhenry, std::int64_t>(l); }
constexpr auto operator"" q_uH(long double l) { return inductance<microhenry, long double>(l); } constexpr auto operator"" _q_uH(long double l) { return inductance<microhenry, long double>(l); }
// mH // mH
constexpr auto operator"" q_mH(unsigned long long l) { return inductance<millihenry, std::int64_t>(l); } constexpr auto operator"" _q_mH(unsigned long long l) { return inductance<millihenry, std::int64_t>(l); }
constexpr auto operator"" q_mH(long double l) { return inductance<millihenry, long double>(l); } constexpr auto operator"" _q_mH(long double l) { return inductance<millihenry, long double>(l); }
// kH // kH
constexpr auto operator"" q_kH(unsigned long long l) { return inductance<kilohenry, std::int64_t>(l); } constexpr auto operator"" _q_kH(unsigned long long l) { return inductance<kilohenry, std::int64_t>(l); }
constexpr auto operator"" q_kH(long double l) { return inductance<kilohenry, long double>(l); } constexpr auto operator"" _q_kH(long double l) { return inductance<kilohenry, long double>(l); }
// MH // MH
constexpr auto operator"" q_MH(unsigned long long l) { return inductance<megahenry, std::int64_t>(l); } constexpr auto operator"" _q_MH(unsigned long long l) { return inductance<megahenry, std::int64_t>(l); }
constexpr auto operator"" q_MH(long double l) { return inductance<megahenry, long double>(l); } constexpr auto operator"" _q_MH(long double l) { return inductance<megahenry, long double>(l); }
// GH // GH
constexpr auto operator"" q_GH(unsigned long long l) { return inductance<gigahenry, std::int64_t>(l); } constexpr auto operator"" _q_GH(unsigned long long l) { return inductance<gigahenry, std::int64_t>(l); }
constexpr auto operator"" q_GH(long double l) { return inductance<gigahenry, long double>(l); } constexpr auto operator"" _q_GH(long double l) { return inductance<gigahenry, long double>(l); }
// TH // TH
constexpr auto operator"" q_TH(unsigned long long l) { return inductance<terahenry, std::int64_t>(l); } constexpr auto operator"" _q_TH(unsigned long long l) { return inductance<terahenry, std::int64_t>(l); }
constexpr auto operator"" q_TH(long double l) { return inductance<terahenry, long double>(l); } constexpr auto operator"" _q_TH(long double l) { return inductance<terahenry, long double>(l); }
// PH // PH
constexpr auto operator"" q_PH(unsigned long long l) { return inductance<petahenry, std::int64_t>(l); } constexpr auto operator"" _q_PH(unsigned long long l) { return inductance<petahenry, std::int64_t>(l); }
constexpr auto operator"" q_PH(long double l) { return inductance<petahenry, long double>(l); } constexpr auto operator"" _q_PH(long double l) { return inductance<petahenry, long double>(l); }
// EH // EH
constexpr auto operator"" q_EH(unsigned long long l) { return inductance<exahenry, std::int64_t>(l); } constexpr auto operator"" _q_EH(unsigned long long l) { return inductance<exahenry, std::int64_t>(l); }
constexpr auto operator"" q_EH(long double l) { return inductance<exahenry, long double>(l); } constexpr auto operator"" _q_EH(long double l) { return inductance<exahenry, long double>(l); }
// ZH // ZH
constexpr auto operator"" q_ZH(unsigned long long l) { return inductance<zettahenry, std::int64_t>(l); } constexpr auto operator"" _q_ZH(unsigned long long l) { return inductance<zettahenry, std::int64_t>(l); }
constexpr auto operator"" q_ZH(long double l) { return inductance<zettahenry, long double>(l); } constexpr auto operator"" _q_ZH(long double l) { return inductance<zettahenry, long double>(l); }
// YH // YH
constexpr auto operator"" q_YH(unsigned long long l) { return inductance<yottahenry, std::int64_t>(l); } constexpr auto operator"" _q_YH(unsigned long long l) { return inductance<yottahenry, std::int64_t>(l); }
constexpr auto operator"" q_YH(long double l) { return inductance<yottahenry, long double>(l); } constexpr auto operator"" _q_YH(long double l) { return inductance<yottahenry, long double>(l); }
} // namespace literals } // namespace literals

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

@ -60,92 +60,92 @@ using length = quantity<dim_length, U, Rep>;
inline namespace literals { inline namespace literals {
// m // m
constexpr auto operator"" q_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"" q_m(long double l) { return length<metre, long double>(l); } constexpr auto operator"" _q_m(long double l) { return length<metre, long double>(l); }
// ym // ym
constexpr auto operator"" q_ym(unsigned long long l) { return length<yoctometre, std::int64_t>(l); } constexpr auto operator"" _q_ym(unsigned long long l) { return length<yoctometre, std::int64_t>(l); }
constexpr auto operator"" q_ym(long double l) { return length<yoctometre, long double>(l); } constexpr auto operator"" _q_ym(long double l) { return length<yoctometre, long double>(l); }
// zm // zm
constexpr auto operator"" q_zm(unsigned long long l) { return length<zeptometre, std::int64_t>(l); } constexpr auto operator"" _q_zm(unsigned long long l) { return length<zeptometre, std::int64_t>(l); }
constexpr auto operator"" q_zm(long double l) { return length<zeptometre, long double>(l); } constexpr auto operator"" _q_zm(long double l) { return length<zeptometre, long double>(l); }
// am // am
constexpr auto operator"" q_am(unsigned long long l) { return length<attometre, std::int64_t>(l); } constexpr auto operator"" _q_am(unsigned long long l) { return length<attometre, std::int64_t>(l); }
constexpr auto operator"" q_am(long double l) { return length<attometre, long double>(l); } constexpr auto operator"" _q_am(long double l) { return length<attometre, long double>(l); }
// fm // fm
constexpr auto operator"" q_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"" q_fm(long double l) { return length<femtometre, long double>(l); } constexpr auto operator"" _q_fm(long double l) { return length<femtometre, long double>(l); }
// pm // pm
constexpr auto operator"" q_pm(unsigned long long l) { return length<picometre, std::int64_t>(l); } constexpr auto operator"" _q_pm(unsigned long long l) { return length<picometre, std::int64_t>(l); }
constexpr auto operator"" q_pm(long double l) { return length<picometre, long double>(l); } constexpr auto operator"" _q_pm(long double l) { return length<picometre, long double>(l); }
// nm // nm
constexpr auto operator"" q_nm(unsigned long long l) { return length<nanometre, std::int64_t>(l); } constexpr auto operator"" _q_nm(unsigned long long l) { return length<nanometre, std::int64_t>(l); }
constexpr auto operator"" q_nm(long double l) { return length<nanometre, long double>(l); } constexpr auto operator"" _q_nm(long double l) { return length<nanometre, long double>(l); }
// um // um
constexpr auto operator"" q_um(unsigned long long l) { return length<micrometre, std::int64_t>(l); } constexpr auto operator"" _q_um(unsigned long long l) { return length<micrometre, std::int64_t>(l); }
constexpr auto operator"" q_um(long double l) { return length<micrometre, long double>(l); } constexpr auto operator"" _q_um(long double l) { return length<micrometre, long double>(l); }
// mm // mm
constexpr auto operator"" q_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"" q_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"" q_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"" q_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"" q_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"" q_dm(long double l) { return length<decimetre, long double>(l); } constexpr auto operator"" _q_dm(long double l) { return length<decimetre, long double>(l); }
// dam // dam
constexpr auto operator"" q_dam(unsigned long long l) { return length<decametre, std::int64_t>(l); } constexpr auto operator"" _q_dam(unsigned long long l) { return length<decametre, std::int64_t>(l); }
constexpr auto operator"" q_dam(long double l) { return length<decametre, long double>(l); } constexpr auto operator"" _q_dam(long double l) { return length<decametre, long double>(l); }
// hm // hm
constexpr auto operator"" q_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"" q_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"" q_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"" q_km(long double l) { return length<kilometre, long double>(l); } constexpr auto operator"" _q_km(long double l) { return length<kilometre, long double>(l); }
// Mm // Mm
constexpr auto operator"" q_Mm(unsigned long long l) { return length<megametre, std::int64_t>(l); } constexpr auto operator"" _q_Mm(unsigned long long l) { return length<megametre, std::int64_t>(l); }
constexpr auto operator"" q_Mm(long double l) { return length<megametre, long double>(l); } constexpr auto operator"" _q_Mm(long double l) { return length<megametre, long double>(l); }
// Gm // Gm
constexpr auto operator"" q_Gm(unsigned long long l) { return length<gigametre, std::int64_t>(l); } constexpr auto operator"" _q_Gm(unsigned long long l) { return length<gigametre, std::int64_t>(l); }
constexpr auto operator"" q_Gm(long double l) { return length<gigametre, long double>(l); } constexpr auto operator"" _q_Gm(long double l) { return length<gigametre, long double>(l); }
// Tm // Tm
constexpr auto operator"" q_Tm(unsigned long long l) { return length<terametre, std::int64_t>(l); } constexpr auto operator"" _q_Tm(unsigned long long l) { return length<terametre, std::int64_t>(l); }
constexpr auto operator"" q_Tm(long double l) { return length<terametre, long double>(l); } constexpr auto operator"" _q_Tm(long double l) { return length<terametre, long double>(l); }
// Pm // Pm
constexpr auto operator"" q_Pm(unsigned long long l) { return length<petametre, std::int64_t>(l); } constexpr auto operator"" _q_Pm(unsigned long long l) { return length<petametre, std::int64_t>(l); }
constexpr auto operator"" q_Pm(long double l) { return length<petametre, long double>(l); } constexpr auto operator"" _q_Pm(long double l) { return length<petametre, long double>(l); }
// Em // Em
constexpr auto operator"" q_Em(unsigned long long l) { return length<exametre, std::int64_t>(l); } constexpr auto operator"" _q_Em(unsigned long long l) { return length<exametre, std::int64_t>(l); }
constexpr auto operator"" q_Em(long double l) { return length<exametre, long double>(l); } constexpr auto operator"" _q_Em(long double l) { return length<exametre, long double>(l); }
// Zm // Zm
constexpr auto operator"" q_Zm(unsigned long long l) { return length<zettametre, std::int64_t>(l); } constexpr auto operator"" _q_Zm(unsigned long long l) { return length<zettametre, std::int64_t>(l); }
constexpr auto operator"" q_Zm(long double l) { return length<zettametre, long double>(l); } constexpr auto operator"" _q_Zm(long double l) { return length<zettametre, long double>(l); }
// Ym // Ym
constexpr auto operator"" q_Ym(unsigned long long l) { return length<yottametre, std::int64_t>(l); } constexpr auto operator"" _q_Ym(unsigned long long l) { return length<yottametre, std::int64_t>(l); }
constexpr auto operator"" q_Ym(long double l) { return length<yottametre, long double>(l); } constexpr auto operator"" _q_Ym(long double l) { return length<yottametre, long double>(l); }
// au // au
constexpr auto operator"" q_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"" q_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/luminance.h
View File

@ -38,8 +38,8 @@ using luminance = quantity<dim_luminance, U, Rep>;
inline namespace literals { inline namespace literals {
// cd/m² // cd/m²
constexpr auto operator"" q_cd_per_m2(unsigned long long l) { return luminance<candela_per_metre_sq, std::int64_t>(l); } constexpr auto operator"" _q_cd_per_m2(unsigned long long l) { return luminance<candela_per_metre_sq, std::int64_t>(l); }
constexpr auto operator"" q_cd_per_m2(long double l) { return luminance<candela_per_metre_sq, long double>(l); } constexpr auto operator"" _q_cd_per_m2(long double l) { return luminance<candela_per_metre_sq, long double>(l); }
} // namespace literals } // namespace literals

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

@ -58,88 +58,88 @@ using luminous_intensity = quantity<dim_luminous_intensity, U, Rep>;
inline namespace literals { inline namespace literals {
// cd // cd
constexpr auto operator"" q_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"" q_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); }
// ycd // ycd
constexpr auto operator"" q_ycd(unsigned long long l) { return luminous_intensity<yoctocandela, std::int64_t>(l); } constexpr auto operator"" _q_ycd(unsigned long long l) { return luminous_intensity<yoctocandela, std::int64_t>(l); }
constexpr auto operator"" q_ycd(long double l) { return luminous_intensity<yoctocandela, long double>(l); } constexpr auto operator"" _q_ycd(long double l) { return luminous_intensity<yoctocandela, long double>(l); }
// zcd // zcd
constexpr auto operator"" q_zcd(unsigned long long l) { return luminous_intensity<zeptocandela, std::int64_t>(l); } constexpr auto operator"" _q_zcd(unsigned long long l) { return luminous_intensity<zeptocandela, std::int64_t>(l); }
constexpr auto operator"" q_zcd(long double l) { return luminous_intensity<zeptocandela, long double>(l); } constexpr auto operator"" _q_zcd(long double l) { return luminous_intensity<zeptocandela, long double>(l); }
// acd // acd
constexpr auto operator"" q_acd(unsigned long long l) { return luminous_intensity<attocandela, std::int64_t>(l); } constexpr auto operator"" _q_acd(unsigned long long l) { return luminous_intensity<attocandela, std::int64_t>(l); }
constexpr auto operator"" q_acd(long double l) { return luminous_intensity<attocandela, long double>(l); } constexpr auto operator"" _q_acd(long double l) { return luminous_intensity<attocandela, long double>(l); }
// fcd // fcd
constexpr auto operator"" q_fcd(unsigned long long l) { return luminous_intensity<femtocandela, std::int64_t>(l); } constexpr auto operator"" _q_fcd(unsigned long long l) { return luminous_intensity<femtocandela, std::int64_t>(l); }
constexpr auto operator"" q_fcd(long double l) { return luminous_intensity<femtocandela, long double>(l); } constexpr auto operator"" _q_fcd(long double l) { return luminous_intensity<femtocandela, long double>(l); }
// pcd // pcd
constexpr auto operator"" q_pcd(unsigned long long l) { return luminous_intensity<picocandela, std::int64_t>(l); } constexpr auto operator"" _q_pcd(unsigned long long l) { return luminous_intensity<picocandela, std::int64_t>(l); }
constexpr auto operator"" q_pcd(long double l) { return luminous_intensity<picocandela, long double>(l); } constexpr auto operator"" _q_pcd(long double l) { return luminous_intensity<picocandela, long double>(l); }
// ncd // ncd
constexpr auto operator"" q_ncd(unsigned long long l) { return luminous_intensity<nanocandela, std::int64_t>(l); } constexpr auto operator"" _q_ncd(unsigned long long l) { return luminous_intensity<nanocandela, std::int64_t>(l); }
constexpr auto operator"" q_ncd(long double l) { return luminous_intensity<nanocandela, long double>(l); } constexpr auto operator"" _q_ncd(long double l) { return luminous_intensity<nanocandela, long double>(l); }
// ucd // ucd
constexpr auto operator"" q_ucd(unsigned long long l) { return luminous_intensity<microcandela, std::int64_t>(l); } constexpr auto operator"" _q_ucd(unsigned long long l) { return luminous_intensity<microcandela, std::int64_t>(l); }
constexpr auto operator"" q_ucd(long double l) { return luminous_intensity<microcandela, long double>(l); } constexpr auto operator"" _q_ucd(long double l) { return luminous_intensity<microcandela, long double>(l); }
// mcd // mcd
constexpr auto operator"" q_mcd(unsigned long long l) { return luminous_intensity<millicandela, std::int64_t>(l); } constexpr auto operator"" _q_mcd(unsigned long long l) { return luminous_intensity<millicandela, std::int64_t>(l); }
constexpr auto operator"" q_mcd(long double l) { return luminous_intensity<millicandela, long double>(l); } constexpr auto operator"" _q_mcd(long double l) { return luminous_intensity<millicandela, long double>(l); }
// ccd // ccd
constexpr auto operator"" q_ccd(unsigned long long l) { return luminous_intensity<centicandela, std::int64_t>(l); } constexpr auto operator"" _q_ccd(unsigned long long l) { return luminous_intensity<centicandela, std::int64_t>(l); }
constexpr auto operator"" q_ccd(long double l) { return luminous_intensity<centicandela, long double>(l); } constexpr auto operator"" _q_ccd(long double l) { return luminous_intensity<centicandela, long double>(l); }
// dcd // dcd
constexpr auto operator"" q_dcd(unsigned long long l) { return luminous_intensity<decicandela, std::int64_t>(l); } constexpr auto operator"" _q_dcd(unsigned long long l) { return luminous_intensity<decicandela, std::int64_t>(l); }
constexpr auto operator"" q_dcd(long double l) { return luminous_intensity<decicandela, long double>(l); } constexpr auto operator"" _q_dcd(long double l) { return luminous_intensity<decicandela, long double>(l); }
// dacd // dacd
constexpr auto operator"" q_dacd(unsigned long long l) { return luminous_intensity<decacandela, std::int64_t>(l); } constexpr auto operator"" _q_dacd(unsigned long long l) { return luminous_intensity<decacandela, std::int64_t>(l); }
constexpr auto operator"" q_dacd(long double l) { return luminous_intensity<decacandela, long double>(l); } constexpr auto operator"" _q_dacd(long double l) { return luminous_intensity<decacandela, long double>(l); }
// hcd // hcd
constexpr auto operator"" q_hcd(unsigned long long l) { return luminous_intensity<hectocandela, std::int64_t>(l); } constexpr auto operator"" _q_hcd(unsigned long long l) { return luminous_intensity<hectocandela, std::int64_t>(l); }
constexpr auto operator"" q_hcd(long double l) { return luminous_intensity<hectocandela, long double>(l); } constexpr auto operator"" _q_hcd(long double l) { return luminous_intensity<hectocandela, long double>(l); }
// kcd // kcd
constexpr auto operator"" q_kcd(unsigned long long l) { return luminous_intensity<kilocandela, std::int64_t>(l); } constexpr auto operator"" _q_kcd(unsigned long long l) { return luminous_intensity<kilocandela, std::int64_t>(l); }
constexpr auto operator"" q_kcd(long double l) { return luminous_intensity<kilocandela, long double>(l); } constexpr auto operator"" _q_kcd(long double l) { return luminous_intensity<kilocandela, long double>(l); }
// Mcd // Mcd
constexpr auto operator"" q_Mcd(unsigned long long l) { return luminous_intensity<megacandela, std::int64_t>(l); } constexpr auto operator"" _q_Mcd(unsigned long long l) { return luminous_intensity<megacandela, std::int64_t>(l); }
constexpr auto operator"" q_Mcd(long double l) { return luminous_intensity<megacandela, long double>(l); } constexpr auto operator"" _q_Mcd(long double l) { return luminous_intensity<megacandela, long double>(l); }
// Gcd // Gcd
constexpr auto operator"" q_Gcd(unsigned long long l) { return luminous_intensity<gigacandela, std::int64_t>(l); } constexpr auto operator"" _q_Gcd(unsigned long long l) { return luminous_intensity<gigacandela, std::int64_t>(l); }
constexpr auto operator"" q_Gcd(long double l) { return luminous_intensity<gigacandela, long double>(l); } constexpr auto operator"" _q_Gcd(long double l) { return luminous_intensity<gigacandela, long double>(l); }
// Tcd // Tcd
constexpr auto operator"" q_Tcd(unsigned long long l) { return luminous_intensity<teracandela, std::int64_t>(l); } constexpr auto operator"" _q_Tcd(unsigned long long l) { return luminous_intensity<teracandela, std::int64_t>(l); }
constexpr auto operator"" q_Tcd(long double l) { return luminous_intensity<teracandela, long double>(l); } constexpr auto operator"" _q_Tcd(long double l) { return luminous_intensity<teracandela, long double>(l); }
// Pcd // Pcd
constexpr auto operator"" q_Pcd(unsigned long long l) { return luminous_intensity<petacandela, std::int64_t>(l); } constexpr auto operator"" _q_Pcd(unsigned long long l) { return luminous_intensity<petacandela, std::int64_t>(l); }
constexpr auto operator"" q_Pcd(long double l) { return luminous_intensity<petacandela, long double>(l); } constexpr auto operator"" _q_Pcd(long double l) { return luminous_intensity<petacandela, long double>(l); }
// Ecd // Ecd
constexpr auto operator"" q_Ecd(unsigned long long l) { return luminous_intensity<exacandela, std::int64_t>(l); } constexpr auto operator"" _q_Ecd(unsigned long long l) { return luminous_intensity<exacandela, std::int64_t>(l); }
constexpr auto operator"" q_Ecd(long double l) { return luminous_intensity<exacandela, long double>(l); } constexpr auto operator"" _q_Ecd(long double l) { return luminous_intensity<exacandela, long double>(l); }
// Zcd // Zcd
constexpr auto operator"" q_Zcd(unsigned long long l) { return luminous_intensity<zettacandela, std::int64_t>(l); } constexpr auto operator"" _q_Zcd(unsigned long long l) { return luminous_intensity<zettacandela, std::int64_t>(l); }
constexpr auto operator"" q_Zcd(long double l) { return luminous_intensity<zettacandela, long double>(l); } constexpr auto operator"" _q_Zcd(long double l) { return luminous_intensity<zettacandela, long double>(l); }
// Ycd // Ycd
constexpr auto operator"" q_Ycd(unsigned long long l) { return luminous_intensity<yottacandela, std::int64_t>(l); } constexpr auto operator"" _q_Ycd(unsigned long long l) { return luminous_intensity<yottacandela, std::int64_t>(l); }
constexpr auto operator"" q_Ycd(long double l) { return luminous_intensity<yottacandela, long double>(l); } constexpr auto operator"" _q_Ycd(long double l) { return luminous_intensity<yottacandela, long double>(l); }
} // namespace literals } // namespace literals

68
src/include/units/physical/si/magnetic_flux.h
View File

@ -56,72 +56,72 @@ using magnetic_flux = quantity<dim_magnetic_flux, U, Rep>;
inline namespace literals { inline namespace literals {
// Wb // Wb
constexpr auto operator"" q_Wb(unsigned long long l) { return magnetic_flux<weber, std::int64_t>(l); } constexpr auto operator"" _q_Wb(unsigned long long l) { return magnetic_flux<weber, std::int64_t>(l); }
constexpr auto operator"" q_Wb(long double l) { return magnetic_flux<weber, long double>(l); } constexpr auto operator"" _q_Wb(long double l) { return magnetic_flux<weber, long double>(l); }
// yWb // yWb
constexpr auto operator"" q_yWb(unsigned long long l) { return magnetic_flux<yoctoweber, std::int64_t>(l); } constexpr auto operator"" _q_yWb(unsigned long long l) { return magnetic_flux<yoctoweber, std::int64_t>(l); }
constexpr auto operator"" q_yWb(long double l) { return magnetic_flux<yoctoweber, long double>(l); } constexpr auto operator"" _q_yWb(long double l) { return magnetic_flux<yoctoweber, long double>(l); }
// zWb // zWb
constexpr auto operator"" q_zWb(unsigned long long l) { return magnetic_flux<zeptoweber, std::int64_t>(l); } constexpr auto operator"" _q_zWb(unsigned long long l) { return magnetic_flux<zeptoweber, std::int64_t>(l); }
constexpr auto operator"" q_zWb(long double l) { return magnetic_flux<zeptoweber, long double>(l); } constexpr auto operator"" _q_zWb(long double l) { return magnetic_flux<zeptoweber, long double>(l); }
// aWb // aWb
constexpr auto operator"" q_aWb(unsigned long long l) { return magnetic_flux<attoweber, std::int64_t>(l); } constexpr auto operator"" _q_aWb(unsigned long long l) { return magnetic_flux<attoweber, std::int64_t>(l); }
constexpr auto operator"" q_aWb(long double l) { return magnetic_flux<attoweber, long double>(l); } constexpr auto operator"" _q_aWb(long double l) { return magnetic_flux<attoweber, long double>(l); }
// fWb // fWb
constexpr auto operator"" q_fWb(unsigned long long l) { return magnetic_flux<femtoweber, std::int64_t>(l); } constexpr auto operator"" _q_fWb(unsigned long long l) { return magnetic_flux<femtoweber, std::int64_t>(l); }
constexpr auto operator"" q_fWb(long double l) { return magnetic_flux<femtoweber, long double>(l); } constexpr auto operator"" _q_fWb(long double l) { return magnetic_flux<femtoweber, long double>(l); }
// pWb // pWb
constexpr auto operator"" q_pWb(unsigned long long l) { return magnetic_flux<picoweber, std::int64_t>(l); } constexpr auto operator"" _q_pWb(unsigned long long l) { return magnetic_flux<picoweber, std::int64_t>(l); }
constexpr auto operator"" q_pWb(long double l) { return magnetic_flux<picoweber, long double>(l); } constexpr auto operator"" _q_pWb(long double l) { return magnetic_flux<picoweber, long double>(l); }
// nWb // nWb
constexpr auto operator"" q_nWb(unsigned long long l) { return magnetic_flux<nanoweber, std::int64_t>(l); } constexpr auto operator"" _q_nWb(unsigned long long l) { return magnetic_flux<nanoweber, std::int64_t>(l); }
constexpr auto operator"" q_nWb(long double l) { return magnetic_flux<nanoweber, long double>(l); } constexpr auto operator"" _q_nWb(long double l) { return magnetic_flux<nanoweber, long double>(l); }
// µWb // µWb
constexpr auto operator"" q_uWb(unsigned long long l) { return magnetic_flux<microweber, std::int64_t>(l); } constexpr auto operator"" _q_uWb(unsigned long long l) { return magnetic_flux<microweber, std::int64_t>(l); }
constexpr auto operator"" q_uWb(long double l) { return magnetic_flux<microweber, long double>(l); } constexpr auto operator"" _q_uWb(long double l) { return magnetic_flux<microweber, long double>(l); }
// mWb // mWb
constexpr auto operator"" q_mWb(unsigned long long l) { return magnetic_flux<milliweber, std::int64_t>(l); } constexpr auto operator"" _q_mWb(unsigned long long l) { return magnetic_flux<milliweber, std::int64_t>(l); }
constexpr auto operator"" q_mWb(long double l) { return magnetic_flux<milliweber, long double>(l); } constexpr auto operator"" _q_mWb(long double l) { return magnetic_flux<milliweber, long double>(l); }
// kWb // kWb
constexpr auto operator"" q_kWb(unsigned long long l) { return magnetic_flux<kiloweber, std::int64_t>(l); } constexpr auto operator"" _q_kWb(unsigned long long l) { return magnetic_flux<kiloweber, std::int64_t>(l); }
constexpr auto operator"" q_kWb(long double l) { return magnetic_flux<kiloweber, long double>(l); } constexpr auto operator"" _q_kWb(long double l) { return magnetic_flux<kiloweber, long double>(l); }
// MWb // MWb
constexpr auto operator"" q_MWb(unsigned long long l) { return magnetic_flux<megaweber, std::int64_t>(l); } constexpr auto operator"" _q_MWb(unsigned long long l) { return magnetic_flux<megaweber, std::int64_t>(l); }
constexpr auto operator"" q_MWb(long double l) { return magnetic_flux<megaweber, long double>(l); } constexpr auto operator"" _q_MWb(long double l) { return magnetic_flux<megaweber, long double>(l); }
// GWb // GWb
constexpr auto operator"" q_GWb(unsigned long long l) { return magnetic_flux<gigaweber, std::int64_t>(l); } constexpr auto operator"" _q_GWb(unsigned long long l) { return magnetic_flux<gigaweber, std::int64_t>(l); }
constexpr auto operator"" q_GWb(long double l) { return magnetic_flux<gigaweber, long double>(l); } constexpr auto operator"" _q_GWb(long double l) { return magnetic_flux<gigaweber, long double>(l); }
// TWb // TWb
constexpr auto operator"" q_TWb(unsigned long long l) { return magnetic_flux<teraweber, std::int64_t>(l); } constexpr auto operator"" _q_TWb(unsigned long long l) { return magnetic_flux<teraweber, std::int64_t>(l); }
constexpr auto operator"" q_TWb(long double l) { return magnetic_flux<teraweber, long double>(l); } constexpr auto operator"" _q_TWb(long double l) { return magnetic_flux<teraweber, long double>(l); }
// PWb // PWb
constexpr auto operator"" q_PWb(unsigned long long l) { return magnetic_flux<petaweber, std::int64_t>(l); } constexpr auto operator"" _q_PWb(unsigned long long l) { return magnetic_flux<petaweber, std::int64_t>(l); }
constexpr auto operator"" q_PWb(long double l) { return magnetic_flux<petaweber, long double>(l); } constexpr auto operator"" _q_PWb(long double l) { return magnetic_flux<petaweber, long double>(l); }
// EWb // EWb
constexpr auto operator"" q_EWb(unsigned long long l) { return magnetic_flux<exaweber, std::int64_t>(l); } constexpr auto operator"" _q_EWb(unsigned long long l) { return magnetic_flux<exaweber, std::int64_t>(l); }
constexpr auto operator"" q_EWb(long double l) { return magnetic_flux<exaweber, long double>(l); } constexpr auto operator"" _q_EWb(long double l) { return magnetic_flux<exaweber, long double>(l); }
// ZWb // ZWb
constexpr auto operator"" q_ZWb(unsigned long long l) { return magnetic_flux<zettaweber, std::int64_t>(l); } constexpr auto operator"" _q_ZWb(unsigned long long l) { return magnetic_flux<zettaweber, std::int64_t>(l); }
constexpr auto operator"" q_ZWb(long double l) { return magnetic_flux<zettaweber, long double>(l); } constexpr auto operator"" _q_ZWb(long double l) { return magnetic_flux<zettaweber, long double>(l); }
// YWb // YWb
constexpr auto operator"" q_YWb(unsigned long long l) { return magnetic_flux<yottaweber, std::int64_t>(l); } constexpr auto operator"" _q_YWb(unsigned long long l) { return magnetic_flux<yottaweber, std::int64_t>(l); }
constexpr auto operator"" q_YWb(long double l) { return magnetic_flux<yottaweber, long double>(l); } constexpr auto operator"" _q_YWb(long double l) { return magnetic_flux<yottaweber, long double>(l); }
} // namespace literals } // namespace literals

72
src/include/units/physical/si/magnetic_induction.h
View File

@ -60,76 +60,76 @@ using magnetic_induction = quantity<dim_magnetic_induction, U, Rep>;
inline namespace literals { inline namespace literals {
// T // T
constexpr auto operator"" q_T(unsigned long long l) { return magnetic_induction<tesla, std::int64_t>(l); } constexpr auto operator"" _q_T(unsigned long long l) { return magnetic_induction<tesla, std::int64_t>(l); }
constexpr auto operator"" q_T(long double l) { return magnetic_induction<tesla, long double>(l); } constexpr auto operator"" _q_T(long double l) { return magnetic_induction<tesla, long double>(l); }
// yT // yT
constexpr auto operator"" q_yT(unsigned long long l) { return magnetic_induction<yoctotesla, std::int64_t>(l); } constexpr auto operator"" _q_yT(unsigned long long l) { return magnetic_induction<yoctotesla, std::int64_t>(l); }
constexpr auto operator"" q_yT(long double l) { return magnetic_induction<yoctotesla, long double>(l); } constexpr auto operator"" _q_yT(long double l) { return magnetic_induction<yoctotesla, long double>(l); }
// zT // zT
constexpr auto operator"" q_zT(unsigned long long l) { return magnetic_induction<zeptotesla, std::int64_t>(l); } constexpr auto operator"" _q_zT(unsigned long long l) { return magnetic_induction<zeptotesla, std::int64_t>(l); }
constexpr auto operator"" q_zT(long double l) { return magnetic_induction<zeptotesla, long double>(l); } constexpr auto operator"" _q_zT(long double l) { return magnetic_induction<zeptotesla, long double>(l); }
// aT // aT
constexpr auto operator"" q_aT(unsigned long long l) { return magnetic_induction<attotesla, std::int64_t>(l); } constexpr auto operator"" _q_aT(unsigned long long l) { return magnetic_induction<attotesla, std::int64_t>(l); }
constexpr auto operator"" q_aT(long double l) { return magnetic_induction<attotesla, long double>(l); } constexpr auto operator"" _q_aT(long double l) { return magnetic_induction<attotesla, long double>(l); }
// fT // fT
constexpr auto operator"" q_fT(unsigned long long l) { return magnetic_induction<femtotesla, std::int64_t>(l); } constexpr auto operator"" _q_fT(unsigned long long l) { return magnetic_induction<femtotesla, std::int64_t>(l); }
constexpr auto operator"" q_fT(long double l) { return magnetic_induction<femtotesla, long double>(l); } constexpr auto operator"" _q_fT(long double l) { return magnetic_induction<femtotesla, long double>(l); }
// pT // pT
constexpr auto operator"" q_pT(unsigned long long l) { return magnetic_induction<picotesla, std::int64_t>(l); } constexpr auto operator"" _q_pT(unsigned long long l) { return magnetic_induction<picotesla, std::int64_t>(l); }
constexpr auto operator"" q_pT(long double l) { return magnetic_induction<picotesla, long double>(l); } constexpr auto operator"" _q_pT(long double l) { return magnetic_induction<picotesla, long double>(l); }
// nT // nT
constexpr auto operator"" q_nT(unsigned long long l) { return magnetic_induction<nanotesla, std::int64_t>(l); } constexpr auto operator"" _q_nT(unsigned long long l) { return magnetic_induction<nanotesla, std::int64_t>(l); }
constexpr auto operator"" q_nT(long double l) { return magnetic_induction<nanotesla, long double>(l); } constexpr auto operator"" _q_nT(long double l) { return magnetic_induction<nanotesla, long double>(l); }
// µT // µT
constexpr auto operator"" q_uT(unsigned long long l) { return magnetic_induction<microtesla, std::int64_t>(l); } constexpr auto operator"" _q_uT(unsigned long long l) { return magnetic_induction<microtesla, std::int64_t>(l); }
constexpr auto operator"" q_uT(long double l) { return magnetic_induction<microtesla, long double>(l); } constexpr auto operator"" _q_uT(long double l) { return magnetic_induction<microtesla, long double>(l); }
// mT // mT
constexpr auto operator"" q_mT(unsigned long long l) { return magnetic_induction<millitesla, std::int64_t>(l); } constexpr auto operator"" _q_mT(unsigned long long l) { return magnetic_induction<millitesla, std::int64_t>(l); }
constexpr auto operator"" q_mT(long double l) { return magnetic_induction<millitesla, long double>(l); } constexpr auto operator"" _q_mT(long double l) { return magnetic_induction<millitesla, long double>(l); }
// kT // kT
constexpr auto operator"" q_kT(unsigned long long l) { return magnetic_induction<kilotesla, std::int64_t>(l); } constexpr auto operator"" _q_kT(unsigned long long l) { return magnetic_induction<kilotesla, std::int64_t>(l); }
constexpr auto operator"" q_kT(long double l) { return magnetic_induction<kilotesla, long double>(l); } constexpr auto operator"" _q_kT(long double l) { return magnetic_induction<kilotesla, long double>(l); }
// MT // MT
constexpr auto operator"" q_MT(unsigned long long l) { return magnetic_induction<megatesla, std::int64_t>(l); } constexpr auto operator"" _q_MT(unsigned long long l) { return magnetic_induction<megatesla, std::int64_t>(l); }
constexpr auto operator"" q_MT(long double l) { return magnetic_induction<megatesla, long double>(l); } constexpr auto operator"" _q_MT(long double l) { return magnetic_induction<megatesla, long double>(l); }
// GT // GT
constexpr auto operator"" q_GT(unsigned long long l) { return magnetic_induction<gigatesla, std::int64_t>(l); } constexpr auto operator"" _q_GT(unsigned long long l) { return magnetic_induction<gigatesla, std::int64_t>(l); }
constexpr auto operator"" q_GT(long double l) { return magnetic_induction<gigatesla, long double>(l); } constexpr auto operator"" _q_GT(long double l) { return magnetic_induction<gigatesla, long double>(l); }
// TT // TT
constexpr auto operator"" q_TT(unsigned long long l) { return magnetic_induction<teratesla, std::int64_t>(l); } constexpr auto operator"" _q_TT(unsigned long long l) { return magnetic_induction<teratesla, std::int64_t>(l); }
constexpr auto operator"" q_TT(long double l) { return magnetic_induction<teratesla, long double>(l); } constexpr auto operator"" _q_TT(long double l) { return magnetic_induction<teratesla, long double>(l); }
// PT // PT
constexpr auto operator"" q_PT(unsigned long long l) { return magnetic_induction<petatesla, std::int64_t>(l); } constexpr auto operator"" _q_PT(unsigned long long l) { return magnetic_induction<petatesla, std::int64_t>(l); }
constexpr auto operator"" q_PT(long double l) { return magnetic_induction<petatesla, long double>(l); } constexpr auto operator"" _q_PT(long double l) { return magnetic_induction<petatesla, long double>(l); }
// ET // ET
constexpr auto operator"" q_ET(unsigned long long l) { return magnetic_induction<exatesla, std::int64_t>(l); } constexpr auto operator"" _q_ET(unsigned long long l) { return magnetic_induction<exatesla, std::int64_t>(l); }
constexpr auto operator"" q_ET(long double l) { return magnetic_induction<exatesla, long double>(l); } constexpr auto operator"" _q_ET(long double l) { return magnetic_induction<exatesla, long double>(l); }
// ZT // ZT
constexpr auto operator"" q_ZT(unsigned long long l) { return magnetic_induction<zettatesla, std::int64_t>(l); } constexpr auto operator"" _q_ZT(unsigned long long l) { return magnetic_induction<zettatesla, std::int64_t>(l); }
constexpr auto operator"" q_ZT(long double l) { return magnetic_induction<zettatesla, long double>(l); } constexpr auto operator"" _q_ZT(long double l) { return magnetic_induction<zettatesla, long double>(l); }
// YT // YT
constexpr auto operator"" q_YT(unsigned long long l) { return magnetic_induction<yottatesla, std::int64_t>(l); } constexpr auto operator"" _q_YT(unsigned long long l) { return magnetic_induction<yottatesla, std::int64_t>(l); }
constexpr auto operator"" q_YT(long double l) { return magnetic_induction<yottatesla, long double>(l); } constexpr auto operator"" _q_YT(long double l) { return magnetic_induction<yottatesla, long double>(l); }
// G // G
constexpr auto operator"" q_G(unsigned long long l) { return magnetic_induction<gauss, std::int64_t>(l); } constexpr auto operator"" _q_G(unsigned long long l) { return magnetic_induction<gauss, std::int64_t>(l); }
constexpr auto operator"" q_G(long double l) { return magnetic_induction<gauss, long double>(l); } constexpr auto operator"" _q_G(long double l) { return magnetic_induction<gauss, long double>(l); }
} // namespace literals } // namespace literals

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

@ -82,176 +82,176 @@ using mass = quantity<dim_mass, U, Rep>;
inline namespace literals { inline namespace literals {
// g // g
constexpr auto operator"" q_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"" q_g(long double l) { return mass<gram, long double>(l); } constexpr auto operator"" _q_g(long double l) { return mass<gram, long double>(l); }
// yg // yg
constexpr auto operator"" q_yg(unsigned long long l) { return mass<yoctogram, std::int64_t>(l); } constexpr auto operator"" _q_yg(unsigned long long l) { return mass<yoctogram, std::int64_t>(l); }
constexpr auto operator"" q_yg(long double l) { return mass<yoctogram, long double>(l); } constexpr auto operator"" _q_yg(long double l) { return mass<yoctogram, long double>(l); }
// zg // zg
constexpr auto operator"" q_zg(unsigned long long l) { return mass<zeptogram, std::int64_t>(l); } constexpr auto operator"" _q_zg(unsigned long long l) { return mass<zeptogram, std::int64_t>(l); }
constexpr auto operator"" q_zg(long double l) { return mass<zeptogram, long double>(l); } constexpr auto operator"" _q_zg(long double l) { return mass<zeptogram, long double>(l); }
// ag // ag
constexpr auto operator"" q_ag(unsigned long long l) { return mass<attogram, std::int64_t>(l); } constexpr auto operator"" _q_ag(unsigned long long l) { return mass<attogram, std::int64_t>(l); }
constexpr auto operator"" q_ag(long double l) { return mass<attogram, long double>(l); } constexpr auto operator"" _q_ag(long double l) { return mass<attogram, long double>(l); }
// fg // fg
constexpr auto operator"" q_fg(unsigned long long l) { return mass<femtogram, std::int64_t>(l); } constexpr auto operator"" _q_fg(unsigned long long l) { return mass<femtogram, std::int64_t>(l); }
constexpr auto operator"" q_fg(long double l) { return mass<femtogram, long double>(l); } constexpr auto operator"" _q_fg(long double l) { return mass<femtogram, long double>(l); }
// pg // pg
constexpr auto operator"" q_pg(unsigned long long l) { return mass<picogram, std::int64_t>(l); } constexpr auto operator"" _q_pg(unsigned long long l) { return mass<picogram, std::int64_t>(l); }
constexpr auto operator"" q_pg(long double l) { return mass<picogram, long double>(l); } constexpr auto operator"" _q_pg(long double l) { return mass<picogram, long double>(l); }
// ng // ng
constexpr auto operator"" q_ng(unsigned long long l) { return mass<nanogram, std::int64_t>(l); } constexpr auto operator"" _q_ng(unsigned long long l) { return mass<nanogram, std::int64_t>(l); }
constexpr auto operator"" q_ng(long double l) { return mass<nanogram, long double>(l); } constexpr auto operator"" _q_ng(long double l) { return mass<nanogram, long double>(l); }
// ug // ug
constexpr auto operator"" q_ug(unsigned long long l) { return mass<microgram, std::int64_t>(l); } constexpr auto operator"" _q_ug(unsigned long long l) { return mass<microgram, std::int64_t>(l); }
constexpr auto operator"" q_ug(long double l) { return mass<microgram, long double>(l); } constexpr auto operator"" _q_ug(long double l) { return mass<microgram, long double>(l); }
// mg // mg
constexpr auto operator"" q_mg(unsigned long long l) { return mass<milligram, std::int64_t>(l); } constexpr auto operator"" _q_mg(unsigned long long l) { return mass<milligram, std::int64_t>(l); }
constexpr auto operator"" q_mg(long double l) { return mass<milligram, long double>(l); } constexpr auto operator"" _q_mg(long double l) { return mass<milligram, long double>(l); }
// cg // cg
constexpr auto operator"" q_cg(unsigned long long l) { return mass<centigram, std::int64_t>(l); } constexpr auto operator"" _q_cg(unsigned long long l) { return mass<centigram, std::int64_t>(l); }
constexpr auto operator"" q_cg(long double l) { return mass<centigram, long double>(l); } constexpr auto operator"" _q_cg(long double l) { return mass<centigram, long double>(l); }
// dg // dg
constexpr auto operator"" q_dg(unsigned long long l) { return mass<decigram, std::int64_t>(l); } constexpr auto operator"" _q_dg(unsigned long long l) { return mass<decigram, std::int64_t>(l); }
constexpr auto operator"" q_dg(long double l) { return mass<decigram, long double>(l); } constexpr auto operator"" _q_dg(long double l) { return mass<decigram, long double>(l); }
// dag // dag
constexpr auto operator"" q_dag(unsigned long long l) { return mass<decagram, std::int64_t>(l); } constexpr auto operator"" _q_dag(unsigned long long l) { return mass<decagram, std::int64_t>(l); }
constexpr auto operator"" q_dag(long double l) { return mass<decagram, long double>(l); } constexpr auto operator"" _q_dag(long double l) { return mass<decagram, long double>(l); }
// hg // hg
constexpr auto operator"" q_hg(unsigned long long l) { return mass<hectogram, std::int64_t>(l); } constexpr auto operator"" _q_hg(unsigned long long l) { return mass<hectogram, std::int64_t>(l); }
constexpr auto operator"" q_hg(long double l) { return mass<hectogram, long double>(l); } constexpr auto operator"" _q_hg(long double l) { return mass<hectogram, long double>(l); }
// kg // kg
constexpr auto operator"" q_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"" q_kg(long double l) { return mass<kilogram, long double>(l); } constexpr auto operator"" _q_kg(long double l) { return mass<kilogram, long double>(l); }
// Mg // Mg
constexpr auto operator"" q_Mg(unsigned long long l) { return mass<megagram, std::int64_t>(l); } constexpr auto operator"" _q_Mg(unsigned long long l) { return mass<megagram, std::int64_t>(l); }
constexpr auto operator"" q_Mg(long double l) { return mass<megagram, long double>(l); } constexpr auto operator"" _q_Mg(long double l) { return mass<megagram, long double>(l); }
// Gg // Gg
constexpr auto operator"" q_Gg(unsigned long long l) { return mass<gigagram, std::int64_t>(l); } constexpr auto operator"" _q_Gg(unsigned long long l) { return mass<gigagram, std::int64_t>(l); }
constexpr auto operator"" q_Gg(long double l) { return mass<gigagram, long double>(l); } constexpr auto operator"" _q_Gg(long double l) { return mass<gigagram, long double>(l); }
// Tg // Tg
constexpr auto operator"" q_Tg(unsigned long long l) { return mass<teragram, std::int64_t>(l); } constexpr auto operator"" _q_Tg(unsigned long long l) { return mass<teragram, std::int64_t>(l); }
constexpr auto operator"" q_Tg(long double l) { return mass<teragram, long double>(l); } constexpr auto operator"" _q_Tg(long double l) { return mass<teragram, long double>(l); }
// Pg // Pg
constexpr auto operator"" q_Pg(unsigned long long l) { return mass<petagram, std::int64_t>(l); } constexpr auto operator"" _q_Pg(unsigned long long l) { return mass<petagram, std::int64_t>(l); }
constexpr auto operator"" q_Pg(long double l) { return mass<petagram, long double>(l); } constexpr auto operator"" _q_Pg(long double l) { return mass<petagram, long double>(l); }
// Eg // Eg
constexpr auto operator"" q_Eg(unsigned long long l) { return mass<exagram, std::int64_t>(l); } constexpr auto operator"" _q_Eg(unsigned long long l) { return mass<exagram, std::int64_t>(l); }
constexpr auto operator"" q_Eg(long double l) { return mass<exagram, long double>(l); } constexpr auto operator"" _q_Eg(long double l) { return mass<exagram, long double>(l); }
// Zg // Zg
constexpr auto operator"" q_Zg(unsigned long long l) { return mass<zettagram, std::int64_t>(l); } constexpr auto operator"" _q_Zg(unsigned long long l) { return mass<zettagram, std::int64_t>(l); }
constexpr auto operator"" q_Zg(long double l) { return mass<zettagram, long double>(l); } constexpr auto operator"" _q_Zg(long double l) { return mass<zettagram, long double>(l); }
// Yg // Yg
constexpr auto operator"" q_Yg(unsigned long long l) { return mass<yottagram, std::int64_t>(l); } constexpr auto operator"" _q_Yg(unsigned long long l) { return mass<yottagram, std::int64_t>(l); }
constexpr auto operator"" q_Yg(long double l) { return mass<yottagram, long double>(l); } constexpr auto operator"" _q_Yg(long double l) { return mass<yottagram, long double>(l); }
// t // t
constexpr auto operator"" q_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"" q_t(long double l) { return mass<tonne, long double>(l); } constexpr auto operator"" _q_t(long double l) { return mass<tonne, long double>(l); }
// yt // yt
constexpr auto operator"" q_yt(unsigned long long l) { return mass<yoctotonne, std::int64_t>(l); } constexpr auto operator"" _q_yt(unsigned long long l) { return mass<yoctotonne, std::int64_t>(l); }
constexpr auto operator"" q_yt(long double l) { return mass<yoctotonne, long double>(l); } constexpr auto operator"" _q_yt(long double l) { return mass<yoctotonne, long double>(l); }
// zt // zt
constexpr auto operator"" q_zt(unsigned long long l) { return mass<zeptotonne, std::int64_t>(l); } constexpr auto operator"" _q_zt(unsigned long long l) { return mass<zeptotonne, std::int64_t>(l); }
constexpr auto operator"" q_zt(long double l) { return mass<zeptotonne, long double>(l); } constexpr auto operator"" _q_zt(long double l) { return mass<zeptotonne, long double>(l); }
// at // at
constexpr auto operator"" q_at(unsigned long long l) { return mass<attotonne, std::int64_t>(l); } constexpr auto operator"" _q_at(unsigned long long l) { return mass<attotonne, std::int64_t>(l); }
constexpr auto operator"" q_at(long double l) { return mass<attotonne, long double>(l); } constexpr auto operator"" _q_at(long double l) { return mass<attotonne, long double>(l); }
// ft // ft
/*constexpr auto operator"" q_ft(unsigned long long l) { return mass<femtotonne, std::int64_t>(l); } /*constexpr auto operator"" _q_ft(unsigned long long l) { return mass<femtotonne, std::int64_t>(l); }
constexpr auto operator"" q_ft(long double l) { return mass<femtotonne, long double>(l); }*/ constexpr auto operator"" _q_ft(long double l) { return mass<femtotonne, long double>(l); }*/
// pt // pt
constexpr auto operator"" q_pt(unsigned long long l) { return mass<picotonne, std::int64_t>(l); } constexpr auto operator"" _q_pt(unsigned long long l) { return mass<picotonne, std::int64_t>(l); }
constexpr auto operator"" q_pt(long double l) { return mass<picotonne, long double>(l); } constexpr auto operator"" _q_pt(long double l) { return mass<picotonne, long double>(l); }
// nt // nt
constexpr auto operator"" q_nt(unsigned long long l) { return mass<nanotonne, std::int64_t>(l); } constexpr auto operator"" _q_nt(unsigned long long l) { return mass<nanotonne, std::int64_t>(l); }
constexpr auto operator"" q_nt(long double l) { return mass<nanotonne, long double>(l); } constexpr auto operator"" _q_nt(long double l) { return mass<nanotonne, long double>(l); }
// ut // ut
constexpr auto operator"" q_ut(unsigned long long l) { return mass<microtonne, std::int64_t>(l); } constexpr auto operator"" _q_ut(unsigned long long l) { return mass<microtonne, std::int64_t>(l); }
constexpr auto operator"" q_ut(long double l) { return mass<microtonne, long double>(l); } constexpr auto operator"" _q_ut(long double l) { return mass<microtonne, long double>(l); }
// mt // mt
constexpr auto operator"" q_mt(unsigned long long l) { return mass<millitonne, std::int64_t>(l); } constexpr auto operator"" _q_mt(unsigned long long l) { return mass<millitonne, std::int64_t>(l); }
constexpr auto operator"" q_mt(long double l) { return mass<millitonne, long double>(l); } constexpr auto operator"" _q_mt(long double l) { return mass<millitonne, long double>(l); }
// ct // ct
constexpr auto operator"" q_ct(unsigned long long l) { return mass<centitonne, std::int64_t>(l); } constexpr auto operator"" _q_ct(unsigned long long l) { return mass<centitonne, std::int64_t>(l); }
constexpr auto operator"" q_ct(long double l) { return mass<centitonne, long double>(l); } constexpr auto operator"" _q_ct(long double l) { return mass<centitonne, long double>(l); }
// dt // dt
constexpr auto operator"" q_dt(unsigned long long l) { return mass<decitonne, std::int64_t>(l); } constexpr auto operator"" _q_dt(unsigned long long l) { return mass<decitonne, std::int64_t>(l); }
constexpr auto operator"" q_dt(long double l) { return mass<decitonne, long double>(l); } constexpr auto operator"" _q_dt(long double l) { return mass<decitonne, long double>(l); }
// dat // dat
constexpr auto operator"" q_dat(unsigned long long l) { return mass<decatonne, std::int64_t>(l); } constexpr auto operator"" _q_dat(unsigned long long l) { return mass<decatonne, std::int64_t>(l); }
constexpr auto operator"" q_dat(long double l) { return mass<decatonne, long double>(l); } constexpr auto operator"" _q_dat(long double l) { return mass<decatonne, long double>(l); }
// ht // ht
constexpr auto operator"" q_ht(unsigned long long l) { return mass<hectotonne, std::int64_t>(l); } constexpr auto operator"" _q_ht(unsigned long long l) { return mass<hectotonne, std::int64_t>(l); }
constexpr auto operator"" q_ht(long double l) { return mass<hectotonne, long double>(l); } constexpr auto operator"" _q_ht(long double l) { return mass<hectotonne, long double>(l); }
// kt // kt
constexpr auto operator"" q_kt(unsigned long long l) { return mass<kilotonne, std::int64_t>(l); } constexpr auto operator"" _q_kt(unsigned long long l) { return mass<kilotonne, std::int64_t>(l); }
constexpr auto operator"" q_kt(long double l) { return mass<kilotonne, long double>(l); } constexpr auto operator"" _q_kt(long double l) { return mass<kilotonne, long double>(l); }
// Mt // Mt
constexpr auto operator"" q_Mt(unsigned long long l) { return mass<megatonne, std::int64_t>(l); } constexpr auto operator"" _q_Mt(unsigned long long l) { return mass<megatonne, std::int64_t>(l); }
constexpr auto operator"" q_Mt(long double l) { return mass<megatonne, long double>(l); } constexpr auto operator"" _q_Mt(long double l) { return mass<megatonne, long double>(l); }
// Gt // Gt
constexpr auto operator"" q_Gt(unsigned long long l) { return mass<gigatonne, std::int64_t>(l); } constexpr auto operator"" _q_Gt(unsigned long long l) { return mass<gigatonne, std::int64_t>(l); }
constexpr auto operator"" q_Gt(long double l) { return mass<gigatonne, long double>(l); } constexpr auto operator"" _q_Gt(long double l) { return mass<gigatonne, long double>(l); }
// Tt // Tt
constexpr auto operator"" q_Tt(unsigned long long l) { return mass<teratonne, std::int64_t>(l); } constexpr auto operator"" _q_Tt(unsigned long long l) { return mass<teratonne, std::int64_t>(l); }
constexpr auto operator"" q_Tt(long double l) { return mass<teratonne, long double>(l); } constexpr auto operator"" _q_Tt(long double l) { return mass<teratonne, long double>(l); }
// Pt // Pt
constexpr auto operator"" q_Pt(unsigned long long l) { return mass<petatonne, std::int64_t>(l); } constexpr auto operator"" _q_Pt(unsigned long long l) { return mass<petatonne, std::int64_t>(l); }
constexpr auto operator"" q_Pt(long double l) { return mass<petatonne, long double>(l); } constexpr auto operator"" _q_Pt(long double l) { return mass<petatonne, long double>(l); }
// Et // Et
constexpr auto operator"" q_Et(unsigned long long l) { return mass<exatonne, std::int64_t>(l); } constexpr auto operator"" _q_Et(unsigned long long l) { return mass<exatonne, std::int64_t>(l); }
constexpr auto operator"" q_Et(long double l) { return mass<exatonne, long double>(l); } constexpr auto operator"" _q_Et(long double l) { return mass<exatonne, long double>(l); }
// Zt // Zt
constexpr auto operator"" q_Zt(unsigned long long l) { return mass<zettatonne, std::int64_t>(l); } constexpr auto operator"" _q_Zt(unsigned long long l) { return mass<zettatonne, std::int64_t>(l); }
constexpr auto operator"" q_Zt(long double l) { return mass<zettatonne, long double>(l); } constexpr auto operator"" _q_Zt(long double l) { return mass<zettatonne, long double>(l); }
// Yt // Yt
constexpr auto operator"" q_Yt(unsigned long long l) { return mass<yottatonne, std::int64_t>(l); } constexpr auto operator"" _q_Yt(unsigned long long l) { return mass<yottatonne, std::int64_t>(l); }
constexpr auto operator"" q_Yt(long double l) { return mass<yottatonne, long double>(l); } constexpr auto operator"" _q_Yt(long double l) { return mass<yottatonne, long double>(l); }
// Da // Da
constexpr auto operator"" q_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"" q_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

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

@ -40,8 +40,8 @@ using molar_energy = quantity<dim_molar_energy, U, Rep>;
inline namespace literals { inline namespace literals {
// H/m // H/m
constexpr auto operator"" q_J_per_mol(unsigned long long l) { return molar_energy<joule_per_mole, std::int64_t>(l); } constexpr auto operator"" _q_J_per_mol(unsigned long long l) { return molar_energy<joule_per_mole, std::int64_t>(l); }
constexpr auto operator"" q_J_per_mol(long double l) { return molar_energy<joule_per_mole, long double>(l); } constexpr auto operator"" _q_J_per_mol(long double l) { return molar_energy<joule_per_mole, long double>(l); }
} // namespace literals } // namespace literals

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

@ -38,8 +38,8 @@ using momentum = quantity<dim_momentum, U, Rep>;
inline namespace literals { inline namespace literals {
// kgmps // kgmps
constexpr auto operator"" q_kg_m_per_s(unsigned long long l) { return momentum<kilogram_metre_per_second, std::int64_t>(l); } constexpr auto operator"" _q_kg_m_per_s(unsigned long long l) { return momentum<kilogram_metre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_kg_m_per_s(long double l) { return momentum<kilogram_metre_per_second, long double>(l); } constexpr auto operator"" _q_kg_m_per_s(long double l) { return momentum<kilogram_metre_per_second, long double>(l); }
} // namespace literals } // namespace literals

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

@ -39,8 +39,8 @@ using permeability = quantity<dim_permeability, U, Rep>;
inline namespace literals { inline namespace literals {
// H/m // H/m
constexpr auto operator"" q_H_per_m(unsigned long long l) { return permeability<henry_per_metre, std::int64_t>(l); } constexpr auto operator"" _q_H_per_m(unsigned long long l) { return permeability<henry_per_metre, std::int64_t>(l); }
constexpr auto operator"" q_H_per_m(long double l) { return permeability<henry_per_metre, long double>(l); } constexpr auto operator"" _q_H_per_m(long double l) { return permeability<henry_per_metre, long double>(l); }
} // namespace literals } // namespace literals

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

@ -39,8 +39,8 @@ using permittivity = quantity<dim_permittivity, U, Rep>;
inline namespace literals { inline namespace literals {
// F/m // F/m
constexpr auto operator"" q_F_per_m(unsigned long long l) { return permittivity<farad_per_metre, std::int64_t>(l); } constexpr auto operator"" _q_F_per_m(unsigned long long l) { return permittivity<farad_per_metre, std::int64_t>(l); }
constexpr auto operator"" q_F_per_m(long double l) { return permittivity<farad_per_metre, long double>(l); } constexpr auto operator"" _q_F_per_m(long double l) { return permittivity<farad_per_metre, long double>(l); }
} // namespace literals } // namespace literals

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

@ -55,72 +55,72 @@ using power = quantity<dim_power, U, Rep>;
inline namespace literals { inline namespace literals {
// W // W
constexpr auto operator"" q_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"" q_W(long double l) { return power<watt, long double>(l); } constexpr auto operator"" _q_W(long double l) { return power<watt, long double>(l); }
// yW // yW
constexpr auto operator"" q_yW(unsigned long long l) { return power<yoctowatt, std::int64_t>(l); } constexpr auto operator"" _q_yW(unsigned long long l) { return power<yoctowatt, std::int64_t>(l); }
constexpr auto operator"" q_yW(long double l) { return power<yoctowatt, long double>(l); } constexpr auto operator"" _q_yW(long double l) { return power<yoctowatt, long double>(l); }
// zW // zW
constexpr auto operator"" q_zW(unsigned long long l) { return power<zeptowatt, std::int64_t>(l); } constexpr auto operator"" _q_zW(unsigned long long l) { return power<zeptowatt, std::int64_t>(l); }
constexpr auto operator"" q_zW(long double l) { return power<zeptowatt, long double>(l); } constexpr auto operator"" _q_zW(long double l) { return power<zeptowatt, long double>(l); }
// aW // aW
constexpr auto operator"" q_aW(unsigned long long l) { return power<attowatt, std::int64_t>(l); } constexpr auto operator"" _q_aW(unsigned long long l) { return power<attowatt, std::int64_t>(l); }
constexpr auto operator"" q_aW(long double l) { return power<attowatt, long double>(l); } constexpr auto operator"" _q_aW(long double l) { return power<attowatt, long double>(l); }
// fW // fW
constexpr auto operator"" q_fW(unsigned long long l) { return power<femtowatt, std::int64_t>(l); } constexpr auto operator"" _q_fW(unsigned long long l) { return power<femtowatt, std::int64_t>(l); }
constexpr auto operator"" q_fW(long double l) { return power<femtowatt, long double>(l); } constexpr auto operator"" _q_fW(long double l) { return power<femtowatt, long double>(l); }
// pW // pW
constexpr auto operator"" q_pW(unsigned long long l) { return power<picowatt, std::int64_t>(l); } constexpr auto operator"" _q_pW(unsigned long long l) { return power<picowatt, std::int64_t>(l); }
constexpr auto operator"" q_pW(long double l) { return power<picowatt, long double>(l); } constexpr auto operator"" _q_pW(long double l) { return power<picowatt, long double>(l); }
// nW // nW
constexpr auto operator"" q_nW(unsigned long long l) { return power<nanowatt, std::int64_t>(l); } constexpr auto operator"" _q_nW(unsigned long long l) { return power<nanowatt, std::int64_t>(l); }
constexpr auto operator"" q_nW(long double l) { return power<nanowatt, long double>(l); } constexpr auto operator"" _q_nW(long double l) { return power<nanowatt, long double>(l); }
// uW // uW
constexpr auto operator"" q_uW(unsigned long long l) { return power<microwatt, std::int64_t>(l); } constexpr auto operator"" _q_uW(unsigned long long l) { return power<microwatt, std::int64_t>(l); }
constexpr auto operator"" q_uW(long double l) { return power<microwatt, long double>(l); } constexpr auto operator"" _q_uW(long double l) { return power<microwatt, long double>(l); }
// mW // mW
constexpr auto operator"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_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"" q_GW(long double l) { return power<gigawatt, long double>(l); } constexpr auto operator"" _q_GW(long double l) { return power<gigawatt, long double>(l); }
// TW // TW
constexpr auto operator"" q_TW(unsigned long long l) { return power<terawatt, std::int64_t>(l); } constexpr auto operator"" _q_TW(unsigned long long l) { return power<terawatt, std::int64_t>(l); }
constexpr auto operator"" q_TW(long double l) { return power<terawatt, long double>(l); } constexpr auto operator"" _q_TW(long double l) { return power<terawatt, long double>(l); }
// PW // PW
constexpr auto operator"" q_PW(unsigned long long l) { return power<petawatt, std::int64_t>(l); } constexpr auto operator"" _q_PW(unsigned long long l) { return power<petawatt, std::int64_t>(l); }
constexpr auto operator"" q_PW(long double l) { return power<petawatt, long double>(l); } constexpr auto operator"" _q_PW(long double l) { return power<petawatt, long double>(l); }
// EW // EW
constexpr auto operator"" q_EW(unsigned long long l) { return power<exawatt, std::int64_t>(l); } constexpr auto operator"" _q_EW(unsigned long long l) { return power<exawatt, std::int64_t>(l); }
constexpr auto operator"" q_EW(long double l) { return power<exawatt, long double>(l); } constexpr auto operator"" _q_EW(long double l) { return power<exawatt, long double>(l); }
// ZW // ZW
constexpr auto operator"" q_ZW(unsigned long long l) { return power<zettawatt, std::int64_t>(l); } constexpr auto operator"" _q_ZW(unsigned long long l) { return power<zettawatt, std::int64_t>(l); }
constexpr auto operator"" q_ZW(long double l) { return power<zettawatt, long double>(l); } constexpr auto operator"" _q_ZW(long double l) { return power<zettawatt, long double>(l); }
// YW // YW
constexpr auto operator"" q_YW(unsigned long long l) { return power<yottawatt, std::int64_t>(l); } constexpr auto operator"" _q_YW(unsigned long long l) { return power<yottawatt, std::int64_t>(l); }
constexpr auto operator"" q_YW(long double l) { return power<yottawatt, long double>(l); } constexpr auto operator"" _q_YW(long double l) { return power<yottawatt, long double>(l); }
} // namespace literals } // namespace literals

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

@ -60,88 +60,88 @@ using pressure = quantity<dim_pressure, U, Rep>;
inline namespace literals { inline namespace literals {
// Pa // Pa
constexpr auto operator"" q_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"" q_Pa(long double l) { return pressure<pascal, long double>(l); } constexpr auto operator"" _q_Pa(long double l) { return pressure<pascal, long double>(l); }
// yPa // yPa
constexpr auto operator"" q_yPa(unsigned long long l) { return pressure<yoctopascal, std::int64_t>(l); } constexpr auto operator"" _q_yPa(unsigned long long l) { return pressure<yoctopascal, std::int64_t>(l); }
constexpr auto operator"" q_yPa(long double l) { return pressure<yoctopascal, long double>(l); } constexpr auto operator"" _q_yPa(long double l) { return pressure<yoctopascal, long double>(l); }
// zPa // zPa
constexpr auto operator"" q_zPa(unsigned long long l) { return pressure<zeptopascal, std::int64_t>(l); } constexpr auto operator"" _q_zPa(unsigned long long l) { return pressure<zeptopascal, std::int64_t>(l); }
constexpr auto operator"" q_zPa(long double l) { return pressure<zeptopascal, long double>(l); } constexpr auto operator"" _q_zPa(long double l) { return pressure<zeptopascal, long double>(l); }
// aPa // aPa
constexpr auto operator"" q_aPa(unsigned long long l) { return pressure<attopascal, std::int64_t>(l); } constexpr auto operator"" _q_aPa(unsigned long long l) { return pressure<attopascal, std::int64_t>(l); }
constexpr auto operator"" q_aPa(long double l) { return pressure<attopascal, long double>(l); } constexpr auto operator"" _q_aPa(long double l) { return pressure<attopascal, long double>(l); }
// fPa // fPa
constexpr auto operator"" q_fPa(unsigned long long l) { return pressure<femtopascal, std::int64_t>(l); } constexpr auto operator"" _q_fPa(unsigned long long l) { return pressure<femtopascal, std::int64_t>(l); }
constexpr auto operator"" q_fPa(long double l) { return pressure<femtopascal, long double>(l); } constexpr auto operator"" _q_fPa(long double l) { return pressure<femtopascal, long double>(l); }
// pPa // pPa
constexpr auto operator"" q_pPa(unsigned long long l) { return pressure<picopascal, std::int64_t>(l); } constexpr auto operator"" _q_pPa(unsigned long long l) { return pressure<picopascal, std::int64_t>(l); }
constexpr auto operator"" q_pPa(long double l) { return pressure<picopascal, long double>(l); } constexpr auto operator"" _q_pPa(long double l) { return pressure<picopascal, long double>(l); }
// nPa // nPa
constexpr auto operator"" q_nPa(unsigned long long l) { return pressure<nanopascal, std::int64_t>(l); } constexpr auto operator"" _q_nPa(unsigned long long l) { return pressure<nanopascal, std::int64_t>(l); }
constexpr auto operator"" q_nPa(long double l) { return pressure<nanopascal, long double>(l); } constexpr auto operator"" _q_nPa(long double l) { return pressure<nanopascal, long double>(l); }
// uPa // uPa
constexpr auto operator"" q_uPa(unsigned long long l) { return pressure<micropascal, std::int64_t>(l); } constexpr auto operator"" _q_uPa(unsigned long long l) { return pressure<micropascal, std::int64_t>(l); }
constexpr auto operator"" q_uPa(long double l) { return pressure<micropascal, long double>(l); } constexpr auto operator"" _q_uPa(long double l) { return pressure<micropascal, long double>(l); }
// mPa // mPa
constexpr auto operator"" q_mPa(unsigned long long l) { return pressure<millipascal, std::int64_t>(l); } constexpr auto operator"" _q_mPa(unsigned long long l) { return pressure<millipascal, std::int64_t>(l); }
constexpr auto operator"" q_mPa(long double l) { return pressure<millipascal, long double>(l); } constexpr auto operator"" _q_mPa(long double l) { return pressure<millipascal, long double>(l); }
// cPa // cPa
constexpr auto operator"" q_cPa(unsigned long long l) { return pressure<centipascal, std::int64_t>(l); } constexpr auto operator"" _q_cPa(unsigned long long l) { return pressure<centipascal, std::int64_t>(l); }
constexpr auto operator"" q_cPa(long double l) { return pressure<centipascal, long double>(l); } constexpr auto operator"" _q_cPa(long double l) { return pressure<centipascal, long double>(l); }
// dPa // dPa
constexpr auto operator"" q_dPa(unsigned long long l) { return pressure<decipascal, std::int64_t>(l); } constexpr auto operator"" _q_dPa(unsigned long long l) { return pressure<decipascal, std::int64_t>(l); }
constexpr auto operator"" q_dPa(long double l) { return pressure<decipascal, long double>(l); } constexpr auto operator"" _q_dPa(long double l) { return pressure<decipascal, long double>(l); }
// daPa // daPa
constexpr auto operator"" q_daPa(unsigned long long l) { return pressure<decapascal, std::int64_t>(l); } constexpr auto operator"" _q_daPa(unsigned long long l) { return pressure<decapascal, std::int64_t>(l); }
constexpr auto operator"" q_daPa(long double l) { return pressure<decapascal, long double>(l); } constexpr auto operator"" _q_daPa(long double l) { return pressure<decapascal, long double>(l); }
// hPa // hPa
constexpr auto operator"" q_hPa(unsigned long long l) { return pressure<hectopascal, std::int64_t>(l); } constexpr auto operator"" _q_hPa(unsigned long long l) { return pressure<hectopascal, std::int64_t>(l); }
constexpr auto operator"" q_hPa(long double l) { return pressure<hectopascal, long double>(l); } constexpr auto operator"" _q_hPa(long double l) { return pressure<hectopascal, long double>(l); }
// kPa // kPa
constexpr auto operator"" q_kPa(unsigned long long l) { return pressure<kilopascal, std::int64_t>(l); } constexpr auto operator"" _q_kPa(unsigned long long l) { return pressure<kilopascal, std::int64_t>(l); }
constexpr auto operator"" q_kPa(long double l) { return pressure<kilopascal, long double>(l); } constexpr auto operator"" _q_kPa(long double l) { return pressure<kilopascal, long double>(l); }
// MPa // MPa
constexpr auto operator"" q_MPa(unsigned long long l) { return pressure<megapascal, std::int64_t>(l); } constexpr auto operator"" _q_MPa(unsigned long long l) { return pressure<megapascal, std::int64_t>(l); }
constexpr auto operator"" q_MPa(long double l) { return pressure<megapascal, long double>(l); } constexpr auto operator"" _q_MPa(long double l) { return pressure<megapascal, long double>(l); }
// GPa // GPa
constexpr auto operator"" q_GPa(unsigned long long l) { return pressure<gigapascal, std::int64_t>(l); } constexpr auto operator"" _q_GPa(unsigned long long l) { return pressure<gigapascal, std::int64_t>(l); }
constexpr auto operator"" q_GPa(long double l) { return pressure<gigapascal, long double>(l); } constexpr auto operator"" _q_GPa(long double l) { return pressure<gigapascal, long double>(l); }
// TPa // TPa
constexpr auto operator"" q_TPa(unsigned long long l) { return pressure<terapascal, std::int64_t>(l); } constexpr auto operator"" _q_TPa(unsigned long long l) { return pressure<terapascal, std::int64_t>(l); }
constexpr auto operator"" q_TPa(long double l) { return pressure<terapascal, long double>(l); } constexpr auto operator"" _q_TPa(long double l) { return pressure<terapascal, long double>(l); }
// PPa // PPa
constexpr auto operator"" q_PPa(unsigned long long l) { return pressure<petapascal, std::int64_t>(l); } constexpr auto operator"" _q_PPa(unsigned long long l) { return pressure<petapascal, std::int64_t>(l); }
constexpr auto operator"" q_PPa(long double l) { return pressure<petapascal, long double>(l); } constexpr auto operator"" _q_PPa(long double l) { return pressure<petapascal, long double>(l); }
// EPa // EPa
constexpr auto operator"" q_EPa(unsigned long long l) { return pressure<exapascal, std::int64_t>(l); } constexpr auto operator"" _q_EPa(unsigned long long l) { return pressure<exapascal, std::int64_t>(l); }
constexpr auto operator"" q_EPa(long double l) { return pressure<exapascal, long double>(l); } constexpr auto operator"" _q_EPa(long double l) { return pressure<exapascal, long double>(l); }
// ZPa // ZPa
constexpr auto operator"" q_ZPa(unsigned long long l) { return pressure<zettapascal, std::int64_t>(l); } constexpr auto operator"" _q_ZPa(unsigned long long l) { return pressure<zettapascal, std::int64_t>(l); }
constexpr auto operator"" q_ZPa(long double l) { return pressure<zettapascal, long double>(l); } constexpr auto operator"" _q_ZPa(long double l) { return pressure<zettapascal, long double>(l); }
// YPa // YPa
constexpr auto operator"" q_YPa(unsigned long long l) { return pressure<yottapascal, std::int64_t>(l); } constexpr auto operator"" _q_YPa(unsigned long long l) { return pressure<yottapascal, std::int64_t>(l); }
constexpr auto operator"" q_YPa(long double l) { return pressure<yottapascal, long double>(l); } constexpr auto operator"" _q_YPa(long double l) { return pressure<yottapascal, long double>(l); }
} // namespace literals } // namespace literals

Some files were not shown because too many files have changed in this diff Show More