From 47a82f466ceb0260363bccd02316efdb5db830ff Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Tue, 11 Feb 2025 17:26:19 +0100 Subject: [PATCH] refactor: `scalar` and `complex` renamed to `real_scalar` and `complex_scalar` respectively + concepts refactoring + electromagnetism fixes --- docs/api_reference/src/quantities.tex | 10 +- ...nging-quantity-safety-to-the-next-level.md | 4 +- docs/blog/posts/isq-part-4-implemeting-isq.md | 2 +- docs/blog/posts/isq-part-6-challenges.md | 4 +- .../framework_basics/design_overview.md | 10 +- example/measurement.cpp | 2 +- src/core/CMakeLists.txt | 1 - src/core/include/mp-units/cartesian_vector.h | 10 +- src/core/include/mp-units/complex.h | 43 -- src/core/include/mp-units/core.h | 1 - .../mp-units/framework/quantity_spec.h | 51 +- .../framework/representation_concepts.h | 225 ++++--- .../mp-units/systems/isq/electromagnetism.h | 50 +- .../include/mp-units/systems/isq/mechanics.h | 34 +- .../include/mp-units/systems/isq_angle.h | 2 +- test/runtime/linear_algebra_test.cpp | 6 +- test/static/concepts_test.cpp | 43 +- test/static/isq_angle_test.cpp | 26 +- test/static/isq_test.cpp | 603 +++++++++--------- test/static/quantity_spec_test.cpp | 20 +- test/static/quantity_test.cpp | 1 - 21 files changed, 569 insertions(+), 579 deletions(-) delete mode 100644 src/core/include/mp-units/complex.h diff --git a/docs/api_reference/src/quantities.tex b/docs/api_reference/src/quantities.tex index f02db946..4c5d30b4 100644 --- a/docs/api_reference/src/quantities.tex +++ b/docs/api_reference/src/quantities.tex @@ -1704,7 +1704,7 @@ and is equal to \item \tcode{Ch} if specified, \item -otherwise, \tcode{quantity_character::scalar} for the first signature, and +otherwise, \tcode{quantity_character::real_scalar} for the first signature, and \item otherwise, \tcode{(BC).character}, where \tcode{BC} is the argument preceding \tcode{Ch} in the signatures above. @@ -1788,7 +1788,7 @@ be packs denoting the template arguments of \item \tcode{\placeholdernc{QUANTITY-CHARACTER-OF}(Pack)} be \begin{codeblock} -std::max({quantity_character::scalar, @\exposidnc{expr-type}@::character...}) +std::max({quantity_character::real_scalar, @\exposidnc{expr-type}@::character...}) \end{codeblock} and \item @@ -1796,7 +1796,7 @@ and \tcode{den_char} be \tcode{\placeholdernc{QUANTITY-CHARACTER-OF}(Dens)}. \end{itemize} The member \tcode{character} is equal to -\tcode{quantity_character::scalar} if \tcode{num_char == den_char} is \tcode{true}, and +\tcode{quantity_character::real_scalar} if \tcode{num_char == den_char} is \tcode{true}, and \tcode{std::max(num_char, den_char)} otherwise. \rSec4[dimless.qty]{Base quantity of dimension one} @@ -4033,8 +4033,8 @@ it represents the numerical value of a quantity\irefiev{112-01-29}. \begin{itemdecl} template -concept @\defexposconceptnc{IsOfCharacter}@ = (Ch == quantity_character::scalar && @\exposconceptnc{Scalar}@) || // \expos - (Ch == quantity_character::complex && @\exposconceptnc{Complex}@) || +concept @\defexposconceptnc{IsOfCharacter}@ = (Ch == quantity_character::real_scalar && @\exposconceptnc{Scalar}@) || // \expos + (Ch == quantity_character::complex_scalar && @\exposconceptnc{Complex}@) || (Ch == quantity_character::vector && @\exposconceptnc{Vector}@); template diff --git a/docs/blog/posts/bringing-quantity-safety-to-the-next-level.md b/docs/blog/posts/bringing-quantity-safety-to-the-next-level.md index 85a71f56..3af819de 100644 --- a/docs/blog/posts/bringing-quantity-safety-to-the-next-level.md +++ b/docs/blog/posts/bringing-quantity-safety-to-the-next-level.md @@ -34,8 +34,8 @@ A quantity character determines the properties and operations that can be perfor Quantities defined by the ISQ may be of the following characters: -- scalar (e.g., _time_, _width_, _speed_, _apparent power_), -- complex (e.g., _complex power_, _voltage phasor_, _electric current phasor_), +- real scalar (e.g., _time_, _width_, _speed_, _apparent power_), +- complex scalar (e.g., _voltage phasor_, _complex power_, _impedance_), - vector (e.g., _displacement_, _velocity_, _force_), - tensor (e.g., _moment of inertia_, _stress_, _strain_). diff --git a/docs/blog/posts/isq-part-4-implemeting-isq.md b/docs/blog/posts/isq-part-4-implemeting-isq.md index 0eea0078..4e3482fd 100644 --- a/docs/blog/posts/isq-part-4-implemeting-isq.md +++ b/docs/blog/posts/isq-part-4-implemeting-isq.md @@ -90,7 +90,7 @@ in one line of code. In the above code: !!! note - Some quantities may be specified to have complex, vector, or tensor character + Some quantities may be specified to have complex scalar, vector, or tensor character (e.g., `displacement`). The quantity character can be set with the last parameter of `quantity_spec`. diff --git a/docs/blog/posts/isq-part-6-challenges.md b/docs/blog/posts/isq-part-6-challenges.md index f658813e..e877d570 100644 --- a/docs/blog/posts/isq-part-6-challenges.md +++ b/docs/blog/posts/isq-part-6-challenges.md @@ -395,11 +395,11 @@ the same kind. Some quantities are more complicated than others. For example, _power_ has: -- scalar quantities expressed in: +- real scalar quantities expressed in: - W (watts) (e.g., _mechanical power_, _active power_), - VA (volt-ampere) (e.g., _apparent power_), - var (e.g., _reactive power_), -- complex quantities expressed in VA (volt-ampere) (e.g., _complex power_). +- complex scalar quantities expressed in VA (volt-ampere) (e.g., _complex power_). How should we model this? Maybe those should be two or three independent trees of quantities, each having its own unit? diff --git a/docs/users_guide/framework_basics/design_overview.md b/docs/users_guide/framework_basics/design_overview.md index 7dbabe49..f31f126c 100644 --- a/docs/users_guide/framework_basics/design_overview.md +++ b/docs/users_guide/framework_basics/design_overview.md @@ -119,15 +119,15 @@ results in the `derived_dimension>` type. [ISO 80000](../../appendix/references.md#ISO80000) explicitly states that quantities (even of the same kind) may have different [characters](../../appendix/glossary.md#character): -- scalar, -- complex, -- vector, -- tensor. +- real scalar (e.g., _time_, _width_, _speed_, _apparent power_), +- complex scalar (e.g., _voltage phasor_, _complex power_, _impedance_), +- vector (e.g., _displacement_, _velocity_, _force_), +- tensor (e.g., _moment of inertia_, _stress_, _strain_). The quantity character in the **mp-units** library is implemented with the `quantity_character` enumeration: ```cpp -enum class quantity_character { scalar, complex, vector, tensor }; +enum class quantity_character { real_scalar, complex_scalar, vector, tensor }; ``` !!! info diff --git a/example/measurement.cpp b/example/measurement.cpp index 1f291cee..f6624a5c 100644 --- a/example/measurement.cpp +++ b/example/measurement.cpp @@ -138,7 +138,7 @@ private: } // namespace -static_assert(mp_units::RepresentationOf, mp_units::quantity_character::scalar>); +static_assert(mp_units::RepresentationOf, mp_units::quantity_character::real_scalar>); static_assert(mp_units::RepresentationOf, mp_units::quantity_character::vector>); namespace { diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index b1f9c89e..c30657a7 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -93,7 +93,6 @@ if(NOT ${projectPrefix}API_FREESTANDING) include/mp-units/bits/requires_hosted.h include/mp-units/ext/format.h include/mp-units/cartesian_vector.h - include/mp-units/complex.h include/mp-units/format.h include/mp-units/math.h include/mp-units/ostream.h diff --git a/src/core/include/mp-units/cartesian_vector.h b/src/core/include/mp-units/cartesian_vector.h index 4af2679a..719f4c67 100644 --- a/src/core/include/mp-units/cartesian_vector.h +++ b/src/core/include/mp-units/cartesian_vector.h @@ -26,6 +26,7 @@ // #include #include +#include #if MP_UNITS_HOSTED #include @@ -46,7 +47,7 @@ import std; namespace mp_units { -MP_UNITS_EXPORT template +MP_UNITS_EXPORT template class cartesian_vector { public: // public members required to satisfy structural type requirements :-( @@ -101,7 +102,12 @@ public: [[nodiscard]] constexpr T magnitude() const requires treat_as_floating_point { - return std::hypot(_coordinates_[0], _coordinates_[1], _coordinates_[2]); + using namespace std; + if constexpr (detail::ComplexScalar) + return hypot(mp_units::modulus(_coordinates_[0]), mp_units::modulus(_coordinates_[1]), + mp_units::modulus(_coordinates_[2])); + else + return hypot(_coordinates_[0], _coordinates_[1], _coordinates_[2]); } [[nodiscard]] constexpr cartesian_vector unit() const diff --git a/src/core/include/mp-units/complex.h b/src/core/include/mp-units/complex.h deleted file mode 100644 index 537fbcc8..00000000 --- a/src/core/include/mp-units/complex.h +++ /dev/null @@ -1,43 +0,0 @@ -// The MIT License (MIT) -// -// Copyright (c) 2018 Mateusz Pusz -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -#pragma once - -#include -// -#include -#include - -#ifndef MP_UNITS_IN_MODULE_INTERFACE -#ifdef MP_UNITS_IMPORT_STD -import std; -#else -#include -#endif -#endif - -namespace mp_units { - -template -constexpr bool disable_scalar> = true; - -} // namespace mp_units diff --git a/src/core/include/mp-units/core.h b/src/core/include/mp-units/core.h index 702f3b6b..ee07fe0f 100644 --- a/src/core/include/mp-units/core.h +++ b/src/core/include/mp-units/core.h @@ -29,7 +29,6 @@ #if MP_UNITS_HOSTED #include -#include #include #include #include diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h index 62128023..e498f3b2 100644 --- a/src/core/include/mp-units/framework/quantity_spec.h +++ b/src/core/include/mp-units/framework/quantity_spec.h @@ -116,12 +116,6 @@ template U> return reference{}; } -// TODO revise the note in the below comment -/** - * @brief Returns the most restrictive character from the list - * - * @note `vector * vector` returns vector (not tensor) - */ template... Ts> [[nodiscard]] consteval quantity_character common_quantity_character(Ts... args) { @@ -133,13 +127,10 @@ template const type_list&) { constexpr quantity_character num = - detail::common_quantity_character(quantity_character::scalar, expr_type::character...); + detail::common_quantity_character(quantity_character::real_scalar, expr_type::character...); constexpr quantity_character den = - detail::common_quantity_character(quantity_character::scalar, expr_type::character...); - if constexpr (num == den) - return quantity_character::scalar; - else - return detail::common_quantity_character(num, den); + detail::common_quantity_character(quantity_character::real_scalar, expr_type::character...); + return detail::max(num, den); } /** @@ -291,7 +282,7 @@ MP_UNITS_EXPORT_END * * This quantity serves as a root/kind for a new hierarchy of quantities of the same kind. * - * Base quantities have scalar character by default. + * Base quantities have real scalar character by default. * * User should derive a strong type from this class template rather than use it directly in the source code. * For example: @@ -312,7 +303,7 @@ MP_UNITS_EXPORT_END * errors. Having them of the same names improves user experience and somehow blurs those separate domains. * * @tparam BaseDimension base dimension for which a base quantity is being defined - * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be scalar + * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be real scalar */ #if MP_UNITS_API_NO_CRTP template @@ -323,7 +314,8 @@ struct quantity_spec : detail::quantity_spec_interface #endif using _base_type_ = quantity_spec; static constexpr detail::BaseDimension auto dimension = Dim; - static constexpr quantity_character character = detail::quantity_character_init(quantity_character::scalar); + static constexpr quantity_character character = + detail::quantity_character_init(quantity_character::real_scalar); }; /** @@ -334,7 +326,7 @@ struct quantity_spec : detail::quantity_spec_interface * * This quantity serves as a root/kind for a new hierarchy of quantities of the same kind. * - * Such quantities by default derive the character from the derived quantity definition. + * Such quantities obtain the character from the derived quantity equation. * * User should derive a strong type from this class template rather than use it directly in the source code. * For example: @@ -342,10 +334,8 @@ struct quantity_spec : detail::quantity_spec_interface * @code{.cpp} * inline constexpr struct area final : quantity_spec(length)> {} area; * inline constexpr struct volume final : quantity_spec(length)> {} volume; - * inline constexpr struct velocity final : quantity_spec {} velocity; - * inline constexpr struct speed final : quantity_spec {} speed; - * inline constexpr struct force final : quantity_spec {} force; - * inline constexpr struct power final : quantity_spec {} power; + * inline constexpr struct velocity final : quantity_spec {} velocity; // vector + * inline constexpr struct force final : quantity_spec {} force; // vector * @endcode * * @note A common convention in this library is to assign the same name for a type and an object of this type. @@ -354,7 +344,7 @@ struct quantity_spec : detail::quantity_spec_interface * errors. Having them of the same names improves user experience and somehow blurs those separate domains. * * @tparam Eq quantity equation specification of a derived quantity - * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be scalar + * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be real scalar */ #if MP_UNITS_API_NO_CRTP template @@ -366,6 +356,9 @@ struct quantity_spec : detail::quantity_spec_interface using _base_type_ = quantity_spec; static constexpr auto _equation_ = Eq; static constexpr Dimension auto dimension = Eq.dimension; + + // TODO static_assert that character property is not passed in Args + static constexpr quantity_character character = detail::quantity_character_init(Eq.character); }; @@ -387,7 +380,8 @@ struct propagate_equation { * Quantities of the same kind form a hierarchy. This specialization adds new leaf to such a tree which * can later be used as a parent by other quantities. * - * The character of those quantities by default is derived from the parent quantity. + * The character of those quantities by default is derived from the parent quantity but can be overriden + * by explicitly passing a property. * * User should derive a strong type from this class template rather than use it directly in the source code. * For example: @@ -397,6 +391,8 @@ struct propagate_equation { * inline constexpr struct height final : quantity_spec {} height; * inline constexpr struct diameter final : quantity_spec {} diameter; * inline constexpr struct displacement final : quantity_spec {} displacement; + * inline constexpr struct voltage_phasor final : quantity_spec { * errors. Having them of the same names improves user experience and somehow blurs those separate domains. * * @tparam Q quantity specification of a parent quantity - * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be scalar + * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be real scalar * or `is_kind` in case the quantity starts a new hierarchy tree of a kind */ #if MP_UNITS_API_NO_CRTP @@ -445,7 +441,7 @@ struct quantity_spec : detail::propagate_equation, detail * can later be used as a parent by other quantities. Additionally, this defintion adds additional * constraints on the derived quantity's equation. * - * The character of those quantities by default is derived from the parent quantity. + * Such quantities obtain the character from the derived quantity equation. * * User should derive a strong type from this class template rather than use it directly in the source code. * For example: @@ -463,8 +459,8 @@ struct quantity_spec : detail::propagate_equation, detail * errors. Having them of the same names improves user experience and somehow blurs those separate domains. * * @tparam Q quantity specification of a parent quantity - * @tparam Args optionally a value of a `quantity_character` in case the base quantity should not be scalar - * or `is_kind` in case the quantity starts a new hierarchy tree of a kind + * @tparam Args optionally a value of `quantity_character` in case the base quantity should not + * be real scalar or `is_kind` in case the quantity starts a new hierarchy tree of a kind */ // clang-format on #if MP_UNITS_API_NO_CRTP @@ -481,6 +477,9 @@ struct quantity_spec : detail::quantity_spec_interface(Eq.character); }; diff --git a/src/core/include/mp-units/framework/representation_concepts.h b/src/core/include/mp-units/framework/representation_concepts.h index 58b806eb..b9fad735 100644 --- a/src/core/include/mp-units/framework/representation_concepts.h +++ b/src/core/include/mp-units/framework/representation_concepts.h @@ -41,34 +41,6 @@ import std; namespace mp_units { -/** - * @brief Quantity character - * - * Scalars, vectors and tensors are mathematical objects that can be used to - * denote certain physical quantities and their values. They are as such - * independent of the particular choice of a coordinate system, whereas - * each scalar component of a vector or a tensor and each component vector and - * component tensor depend on that choice. - * - * A scalar is a physical quantity that has magnitude but no direction. - * - * A complex is a physical quantity that is represented with a complex number. - * - * Vectors are physical quantities that possess both magnitude and direction - * and whose operations obey the axioms of a vector space. - * - * Tensors can be used to describe more general physical quantities. - * For example, the Cauchy stress tensor possess magnitude, direction, - * and orientation qualities. - */ -MP_UNITS_EXPORT enum class quantity_character : std::int8_t { scalar, complex, vector, tensor }; - -MP_UNITS_EXPORT template -constexpr bool disable_scalar = false; - -template<> -MP_UNITS_INLINE constexpr bool disable_scalar = true; - namespace detail { template @@ -82,23 +54,44 @@ concept ScalableWith = requires(const T v, const S s) { }; template -concept Scalar = (!disable_scalar) && - requires(const T a, const T b) { - { -a } -> std::common_with; - { a + b } -> std::common_with; - { a - b } -> std::common_with; - } && ScalableWith -#if MP_UNITS_COMP_GCC != 12 && !defined(MP_UNITS_XCODE15_HACKS) - && WeaklyRegular -#endif - ; +concept Addable = requires(const T a, const T b) { + { -a } -> std::common_with; + { a + b } -> std::common_with; + { a - b } -> std::common_with; +}; -namespace real_impl { +} // namespace detail + +/** + * @brief Quantity character + * + * Scalars, vectors and tensors are mathematical objects that can be used to + * denote certain physical quantities and their values. They are as such + * independent of the particular choice of a coordinate system, whereas + * each scalar component of a vector or a tensor and each component vector and + * component tensor depend on that choice. + * + * A scalar is a physical quantity that has magnitude but no direction. It might + * be a real or complex number which affects which operations are allowed on a quantity. + * + * Vectors are physical quantities that possess both magnitude and direction + * and whose operations obey the axioms of a vector space. + * + * Tensors can be used to describe more general physical quantities. + * For example, the Cauchy stress tensor possess magnitude, direction, + * and orientation qualities. + */ +MP_UNITS_EXPORT enum class quantity_character : std::int8_t { real_scalar, complex_scalar, vector, tensor }; + +/////////////// COMPLEX SCALAR /////////////// + +namespace detail::real_impl { void real() = delete; // poison pill struct real_t { - [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const + // TODO how to constrain the return with RealScalar? + [[nodiscard]] constexpr auto operator()(const WeaklyRegular auto& clx) const requires requires { clx.real(); } || requires { real(clx); } { if constexpr (requires { clx.real(); }) @@ -108,9 +101,7 @@ struct real_t { } }; -} // namespace real_impl - -} // namespace detail +} // namespace detail::real_impl inline namespace cpo { @@ -123,7 +114,8 @@ namespace detail::imag_impl { void imag() = delete; // poison pill struct imag_t { - [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const + // TODO how to constrain the return with RealScalar? + [[nodiscard]] constexpr auto operator()(const WeaklyRegular auto& clx) const requires requires { clx.imag(); } || requires { imag(clx); } { if constexpr (requires { clx.imag(); }) @@ -147,7 +139,8 @@ void modulus() = delete; // poison pill void abs() = delete; // poison pill struct modulus_t { - [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const + // TODO how to constrain the return with RealScalar? + [[nodiscard]] constexpr auto operator()(const WeaklyRegular auto& clx) const requires requires { clx.modulus(); } || requires { modulus(clx); } || requires { clx.abs(); } || requires { abs(clx); } { @@ -155,7 +148,7 @@ struct modulus_t { return clx.modulus(); else if constexpr (requires { modulus(clx); }) return modulus(clx); - // `std` made a precedence of using `abs` for modulo on `std::complex` + // `std` made a precedence of using `abs` for modulus on `std::complex` else if constexpr (requires { clx.abs(); }) return clx.abs(); else if constexpr (requires { abs(clx); }) @@ -171,30 +164,55 @@ MP_UNITS_EXPORT inline constexpr ::mp_units::detail::modulus_impl::modulus_t mod } +namespace detail { + +template +concept ComplexScalar = + // TODO should the below be provided? + // (!disable_complex) && + Addable && ScalableWith && + requires(const T v, const T& ref) { + ::mp_units::real(v); + ::mp_units::imag(v); + ::mp_units::modulus(v); + requires ScalableWith; + requires std::constructible_from; + } +#ifndef MP_UNITS_XCODE15_HACKS + && WeaklyRegular +#endif + ; + +} // namespace detail + + +/////////////// REAL SCALAR /////////////// + MP_UNITS_EXPORT template -constexpr bool disable_complex = false; +constexpr bool disable_real = false; + +template<> +MP_UNITS_INLINE constexpr bool disable_real = true; namespace detail { template -concept Complex = (!disable_complex) && - requires(const T a, const T b, const T& c) { - { -a } -> std::common_with; - { a + b } -> std::common_with; - { a - b } -> std::common_with; - { a* b } -> std::common_with; - { a / b } -> std::common_with; - ::mp_units::real(a); - ::mp_units::imag(a); - ::mp_units::modulus(a); - requires ScalableWith; - requires std::constructible_from; - } -#ifndef MP_UNITS_XCODE15_HACKS - && WeaklyRegular +concept RealScalar = + (!disable_real) && Addable && ScalableWith && std::totally_ordered && (!ComplexScalar) +#if MP_UNITS_COMP_GCC != 12 && !defined(MP_UNITS_XCODE15_HACKS) + && WeaklyRegular #endif ; -namespace magnitude_impl { + +template +concept Scalar = RealScalar || ComplexScalar; + +} // namespace detail + + +/////////////// VECTOR /////////////// + +namespace detail::magnitude_impl { void magnitude() = delete; // poison pill void abs() = delete; // poison pill @@ -203,32 +221,29 @@ struct magnitude_t { template [[nodiscard]] constexpr Scalar auto operator()(const T& vec) const requires requires { vec.magnitude(); } || requires { magnitude(vec); } || - (Scalar && - (requires { vec.abs(); } || requires { abs(vec); } || (std::is_arithmetic_v && (!is_same_v)))) + (RealScalar && (std::is_arithmetic_v || requires { vec.abs(); } || requires { abs(vec); })) { if constexpr (requires { vec.magnitude(); }) return vec.magnitude(); else if constexpr (requires { magnitude(vec); }) return magnitude(vec); - // allow scalar types to represent one dimensional vector quantities - if constexpr (Scalar) { - if constexpr (requires { vec.abs(); }) - return vec.abs(); - else if constexpr (requires { abs(vec); }) - return abs(vec); - else if constexpr (std::is_arithmetic_v && (!is_same_v)) + // allow real types to represent one dimensional vector quantities + if constexpr (RealScalar) { + if constexpr (std::is_arithmetic_v) #if MP_UNITS_HOSTED || __cpp_lib_freestanding_cstdlib >= 202306L return std::abs(vec); #else return vec >= 0 ? vec : -vec; #endif + else if constexpr (requires { vec.abs(); }) + return vec.abs(); + else if constexpr (requires { abs(vec); }) + return abs(vec); } } }; -} // namespace magnitude_impl - -} // namespace detail +} // namespace detail::magnitude_impl inline namespace cpo { @@ -236,22 +251,15 @@ MP_UNITS_EXPORT inline constexpr ::mp_units::detail::magnitude_impl::magnitude_t } -MP_UNITS_EXPORT template -constexpr bool disable_vector = false; - namespace detail { template -concept Vector = (!disable_vector) && - requires(const T a, const T b) { - { -a } -> std::common_with; - { a + b } -> std::common_with; - { a - b } -> std::common_with; - ::mp_units::magnitude(a); - requires ScalableWith; +concept Vector = Addable && + requires(const T v) { + ::mp_units::magnitude(v); + requires ScalableWith; // TODO should we also check for the below (e.g., when `size() > 1` or `2`) // ::mp_units::zero_vector(); - // ::mp_units::unit_vector(a); // ::mp_units::scalar_product(a, b); // ::mp_units::vector_product(a, b); // ::mp_units::tensor_product(a, b); @@ -263,11 +271,11 @@ concept Vector = (!disable_vector) && } // namespace detail +/////////////// TENSOR /////////////// + // MP_UNITS_EXPORT template // constexpr bool disable_tensor = false; -namespace detail { - // TODO provide when some actual operations will be required // template // concept Tensor = (!disable_tensor) && WeaklyRegular && requires(const T a, const T b) { @@ -276,25 +284,33 @@ namespace detail { // ::mp_units::scalar_product(a, b); // }; + +namespace detail { + template constexpr bool is_quantity = false; template using scaling_factor_type_t = conditional, long double, std::intmax_t>; -// TODO how can we use `(!Quantity)` below? +// TODO replace the below and above with the logic from #615 when available template -concept ScalarRepresentation = (!is_quantity) && Scalar && requires(const T v, const scaling_factor_type_t f) { - // scaling +concept ScalableByFactor = requires(const T v, const scaling_factor_type_t f) { { v* f } -> std::common_with; { f* v } -> std::common_with; { v / f } -> std::common_with; }; +// TODO how can we use `(!Quantity)` below? template -concept ComplexRepresentation = - (!is_quantity) && Complex && requires(const T v, const scaling_factor_type_t f) { - // scaling +concept NotQuantity = (!is_quantity); + +template +concept RealScalarRepresentation = NotQuantity && RealScalar && ScalableByFactor; + +template +concept ComplexScalarRepresentation = + NotQuantity && ComplexScalar && requires(const T v, const scaling_factor_type_t f) { // TODO The below conversion to `T` is an exception compared to other representation types // `std::complex` * `U` do not work, but `std::complex` is convertible from `U` // Maybe expose this as a customization point? @@ -304,30 +320,29 @@ concept ComplexRepresentation = }; template -concept VectorRepresentation = (!is_quantity) && Vector && requires(const T v, const scaling_factor_type_t f) { - // scaling - { v* f } -> std::common_with; - { f* v } -> std::common_with; - { v / f } -> std::common_with; -}; +concept ScalarRepresentation = RealScalarRepresentation || ComplexScalarRepresentation; + +template +concept VectorRepresentation = NotQuantity && Vector && ScalableByFactor; // template -// concept TensorRepresentation = (!is_quantity) && Tensor; +// concept TensorRepresentation = NotQuantity && Tensor; } // namespace detail MP_UNITS_EXPORT template -concept Representation = detail::ScalarRepresentation || detail::ComplexRepresentation || - detail::VectorRepresentation; // || detail::TensorRepresentation; +concept Representation = + detail::ScalarRepresentation || detail::VectorRepresentation; // || detail::TensorRepresentation; namespace detail { template concept IsOfCharacter = - (Ch == quantity_character::scalar && Scalar) || (Ch == quantity_character::complex && Complex) || + (Ch == quantity_character::real_scalar && RealScalar) || + (Ch == quantity_character::complex_scalar && ComplexScalar) || (Ch == quantity_character::vector && Vector); // || (Ch == quantity_character::tensor && Tensor); -} +} // namespace detail MP_UNITS_EXPORT template concept RepresentationOf = diff --git a/src/systems/include/mp-units/systems/isq/electromagnetism.h b/src/systems/include/mp-units/systems/isq/electromagnetism.h index 25c4cf74..8e6417c8 100644 --- a/src/systems/include/mp-units/systems/isq/electromagnetism.h +++ b/src/systems/include/mp-units/systems/isq/electromagnetism.h @@ -54,8 +54,8 @@ QUANTITY_SPEC(electric_current_density, electric_charge_density* velocity); QUANTITY_SPEC(linear_electric_current_density, surface_density_of_electric_charge* velocity); // vector QUANTITY_SPEC(electric_field_strength, force / electric_charge); // vector QUANTITY_SPEC(electric_potential, electric_field_strength* length, - quantity_character::scalar); // TODO what is a correct equation here? -QUANTITY_SPEC(electric_potential_difference, electric_potential, quantity_character::scalar); + quantity_character::real_scalar); // TODO what is a correct equation here? +QUANTITY_SPEC(electric_potential_difference, electric_potential, quantity_character::real_scalar); QUANTITY_SPEC(voltage, electric_potential); inline constexpr auto electric_tension = voltage; QUANTITY_SPEC(induced_voltage, voltage); // TODO what is a correct equation here? @@ -73,19 +73,20 @@ inline constexpr auto light_speed_in_vacuum = speed_of_light_in_vacuum; inline constexpr auto luminal_speed = speed_of_light_in_vacuum; QUANTITY_SPEC(electric_constant, inverse(magnetic_constant* pow<2>(speed_of_light_in_vacuum))); inline constexpr auto permittivity_of_vacuum = electric_constant; -QUANTITY_SPEC(permittivity, electric_flux_density / electric_field_strength, quantity_character::scalar); +QUANTITY_SPEC(permittivity, electric_flux_density / electric_field_strength, quantity_character::real_scalar); QUANTITY_SPEC(relative_permittivity, dimensionless, permittivity / electric_constant); QUANTITY_SPEC(electric_susceptibility, dimensionless, - electric_polarization / electric_constant / electric_field_strength, quantity_character::scalar); -QUANTITY_SPEC(electric_flux, electric_flux_density* area, quantity_character::scalar); + electric_polarization / electric_constant / electric_field_strength, quantity_character::real_scalar); +QUANTITY_SPEC(electric_flux, electric_flux_density* area, quantity_character::real_scalar); QUANTITY_SPEC(displacement_current_density, electric_flux_density / time); // vector -QUANTITY_SPEC(displacement_current, electric_current, displacement_current_density* area, quantity_character::scalar); +QUANTITY_SPEC(displacement_current, electric_current, displacement_current_density* area, + quantity_character::real_scalar); QUANTITY_SPEC(total_current, electric_current); QUANTITY_SPEC(total_current_density, electric_current_density); // vector -QUANTITY_SPEC(magnetic_flux, magnetic_flux_density* area, quantity_character::scalar); +QUANTITY_SPEC(magnetic_flux, magnetic_flux_density* area, quantity_character::real_scalar); QUANTITY_SPEC(magnetic_vector_potential, magnetic_flux_density* length); // vector // TODO what is a correct equation here? -QUANTITY_SPEC(protoflux, magnetic_vector_potential* displacement, quantity_character::scalar); +QUANTITY_SPEC(protoflux, magnetic_vector_potential* displacement, quantity_character::real_scalar); QUANTITY_SPEC(linked_magnetic_flux, magnetic_flux); QUANTITY_SPEC(total_magnetic_flux, magnetic_flux); QUANTITY_SPEC(magnetic_moment, electric_current* area, quantity_character::vector); @@ -93,23 +94,24 @@ inline constexpr auto magnetic_area_moment = magnetic_moment; QUANTITY_SPEC(magnetization, magnetic_moment / volume); // vector QUANTITY_SPEC(magnetic_field_strength, magnetization); // vector inline constexpr auto magnetizing_field = magnetic_field_strength; -QUANTITY_SPEC(permeability, magnetic_flux_density / magnetic_field_strength, quantity_character::scalar); +QUANTITY_SPEC(permeability, magnetic_flux_density / magnetic_field_strength, quantity_character::real_scalar); QUANTITY_SPEC(relative_permeability, dimensionless, permeability / magnetic_constant); QUANTITY_SPEC(magnetic_susceptibility, dimensionless, magnetization / magnetic_field_strength, - quantity_character::scalar); + quantity_character::real_scalar); QUANTITY_SPEC(magnetic_polarization, magnetic_constant* magnetization); // vector QUANTITY_SPEC(magnetic_dipole_moment, magnetic_constant* magnetic_moment); // vector -QUANTITY_SPEC(coercivity, magnetic_field_strength, quantity_character::scalar); +QUANTITY_SPEC(coercivity, magnetic_field_strength, quantity_character::real_scalar); inline constexpr auto coercive_field_strength = coercivity; QUANTITY_SPEC(electromagnetic_energy_density, electric_field_strength* electric_flux_density, - quantity_character::scalar); + quantity_character::real_scalar); QUANTITY_SPEC(Poynting_vector, electric_field_strength* magnetic_field_strength); // vector QUANTITY_SPEC(source_voltage, voltage); inline constexpr auto source_tension = source_voltage; QUANTITY_SPEC(magnetic_potential, electric_current); // TODO what is a correct equation here? -QUANTITY_SPEC(magnetic_tension, electric_current, magnetic_field_strength* position_vector, quantity_character::scalar); +QUANTITY_SPEC(magnetic_tension, electric_current, magnetic_field_strength* position_vector, + quantity_character::real_scalar); QUANTITY_SPEC(magnetomotive_force, electric_current, magnetic_field_strength* position_vector, - quantity_character::scalar); + quantity_character::real_scalar); QUANTITY_SPEC(number_of_turns_in_a_winding, dimensionless); QUANTITY_SPEC(reluctance, magnetic_tension / magnetic_flux); QUANTITY_SPEC(permeance, inverse(reluctance)); @@ -118,15 +120,15 @@ inline constexpr auto self_inductance = inductance; QUANTITY_SPEC(mutual_inductance, protoflux / electric_current); QUANTITY_SPEC(coupling_factor, dimensionless, mutual_inductance / pow<1, 2>(pow<2>(self_inductance))); QUANTITY_SPEC(leakage_factor, dimensionless, pow<2>(coupling_factor)); -QUANTITY_SPEC(conductivity, electric_current_density / electric_field_strength, quantity_character::scalar); +QUANTITY_SPEC(conductivity, electric_current_density / electric_field_strength, quantity_character::real_scalar); QUANTITY_SPEC(resistivity, inverse(conductivity)); QUANTITY_SPEC(electromagnetism_power, power, voltage* electric_current); // different name than in ISQ inline constexpr auto instantaneous_power = electromagnetism_power; QUANTITY_SPEC(resistance, voltage / electric_current); QUANTITY_SPEC(conductance, inverse(resistance)); QUANTITY_SPEC(phase_difference, phase_angle); -QUANTITY_SPEC(electric_current_phasor, electric_current, quantity_character::complex); -QUANTITY_SPEC(voltage_phasor, voltage, quantity_character::complex); +QUANTITY_SPEC(electric_current_phasor, electric_current, quantity_character::complex_scalar); +QUANTITY_SPEC(voltage_phasor, voltage, quantity_character::complex_scalar); inline constexpr auto electric_tension_phasor = voltage_phasor; QUANTITY_SPEC(impedance, voltage_phasor / electric_current_phasor); // complex inline constexpr auto complex_impedance = impedance; // complex @@ -134,23 +136,23 @@ QUANTITY_SPEC(impedance_of_vacuum, impedance); // comple inline constexpr auto wave_impedance_in_vacuum = impedance_of_vacuum; // complex QUANTITY_SPEC( resistance_to_alternating_current, impedance, - quantity_character::scalar); // called resistance in the latest ISQ (we use the old name to avoid ambiguity) -QUANTITY_SPEC(reactance, impedance, quantity_character::scalar); -QUANTITY_SPEC(apparent_impedance, impedance, quantity_character::scalar); + quantity_character::real_scalar); // called resistance in the latest ISQ (we use the old name to avoid ambiguity) +QUANTITY_SPEC(reactance, impedance, quantity_character::real_scalar); +QUANTITY_SPEC(apparent_impedance, impedance, quantity_character::real_scalar); QUANTITY_SPEC(admittance, inverse(impedance)); // complex inline constexpr auto complex_admittance = admittance; // complex QUANTITY_SPEC(admittance_of_vacuum, admittance, inverse(impedance_of_vacuum)); // complex QUANTITY_SPEC( conductance_for_alternating_current, conductance, - quantity_character::scalar); // called resistance in the latest ISQ (we use the old name to avoid ambiguity) -QUANTITY_SPEC(susceptance, admittance); -QUANTITY_SPEC(apparent_admittance, admittance, quantity_character::scalar); + quantity_character::real_scalar); // called resistance in the latest ISQ (we use the old name to avoid ambiguity) +QUANTITY_SPEC(susceptance, admittance, quantity_character::real_scalar); +QUANTITY_SPEC(apparent_admittance, admittance, quantity_character::real_scalar); QUANTITY_SPEC(quality_factor, dimensionless, reactance / resistance); QUANTITY_SPEC(loss_factor, dimensionless, inverse(quality_factor)); QUANTITY_SPEC(loss_angle, angular_measure); QUANTITY_SPEC(active_power, isq::power, inverse(period) * (instantaneous_power * time)); QUANTITY_SPEC(complex_power, voltage_phasor* electric_current_phasor); // complex // separate kind -QUANTITY_SPEC(apparent_power, complex_power, quantity_character::scalar); +QUANTITY_SPEC(apparent_power, complex_power, quantity_character::real_scalar); QUANTITY_SPEC(power_factor, dimensionless, active_power / apparent_power); QUANTITY_SPEC(reactive_power, isq::mass* pow<2>(isq::length) / pow<3>(isq::time)); // separate kind QUANTITY_SPEC(non_active_power, pow<1, 2>(pow<2>(apparent_power))); // separate kind diff --git a/src/systems/include/mp-units/systems/isq/mechanics.h b/src/systems/include/mp-units/systems/isq/mechanics.h index 41157143..63c71467 100644 --- a/src/systems/include/mp-units/systems/isq/mechanics.h +++ b/src/systems/include/mp-units/systems/isq/mechanics.h @@ -60,16 +60,16 @@ QUANTITY_SPEC(impulse, force* time); // vector QUANTITY_SPEC(angular_momentum, position_vector* momentum); // vector QUANTITY_SPEC(moment_of_inertia, angular_momentum / angular_velocity, quantity_character::tensor); QUANTITY_SPEC(moment_of_force, position_vector* force); // vector -QUANTITY_SPEC(torque, moment_of_force, quantity_character::scalar); +QUANTITY_SPEC(torque, moment_of_force, quantity_character::real_scalar); QUANTITY_SPEC(angular_impulse, moment_of_force* time); // vector -QUANTITY_SPEC(pressure, force / area, quantity_character::scalar); +QUANTITY_SPEC(pressure, force / area, quantity_character::real_scalar); QUANTITY_SPEC(gauge_pressure, pressure); QUANTITY_SPEC(stress, pressure, quantity_character::tensor); -QUANTITY_SPEC(normal_stress, pressure, quantity_character::scalar); -QUANTITY_SPEC(shear_stress, pressure, quantity_character::scalar); +QUANTITY_SPEC(normal_stress, pressure, quantity_character::real_scalar); +QUANTITY_SPEC(shear_stress, pressure, quantity_character::real_scalar); QUANTITY_SPEC(strain, dimensionless, quantity_character::tensor); QUANTITY_SPEC(relative_linear_strain, length / length); -QUANTITY_SPEC(shear_strain, dimensionless, displacement / thickness, quantity_character::scalar); +QUANTITY_SPEC(shear_strain, dimensionless, displacement / thickness, quantity_character::real_scalar); QUANTITY_SPEC(relative_volume_strain, volume / volume); QUANTITY_SPEC(Poisson_number, dimensionless, width / length); QUANTITY_SPEC(modulus_of_elasticity, normal_stress / relative_linear_strain); @@ -82,30 +82,32 @@ QUANTITY_SPEC(compressibility, inverse(volume) * (volume / pressure)); QUANTITY_SPEC(second_axial_moment_of_area, pow<2>(radial_distance) * area); QUANTITY_SPEC(second_polar_moment_of_area, pow<2>(radial_distance) * area); QUANTITY_SPEC(section_modulus, second_axial_moment_of_area / radial_distance); -QUANTITY_SPEC(static_friction_coefficient, dimensionless, static_friction_force / force, quantity_character::scalar); +QUANTITY_SPEC(static_friction_coefficient, dimensionless, static_friction_force / force, + quantity_character::real_scalar); inline constexpr auto static_friction_factor = static_friction_coefficient; inline constexpr auto coefficient_of_static_friction = static_friction_coefficient; -QUANTITY_SPEC(kinetic_friction_factor, dimensionless, kinetic_friction_force / force, quantity_character::scalar); +QUANTITY_SPEC(kinetic_friction_factor, dimensionless, kinetic_friction_force / force, quantity_character::real_scalar); inline constexpr auto dynamic_friction_factor = kinetic_friction_factor; -QUANTITY_SPEC(rolling_resistance_factor, force / force, quantity_character::scalar); +QUANTITY_SPEC(rolling_resistance_factor, force / force, quantity_character::real_scalar); QUANTITY_SPEC(drag_coefficient, dimensionless, drag_force / (mass_density * pow<2>(speed) * area), - quantity_character::scalar); + quantity_character::real_scalar); inline constexpr auto drag_factor = drag_coefficient; -QUANTITY_SPEC(dynamic_viscosity, shear_stress* length / velocity, quantity_character::scalar); +QUANTITY_SPEC(dynamic_viscosity, shear_stress* length / velocity, quantity_character::real_scalar); QUANTITY_SPEC(kinematic_viscosity, dynamic_viscosity / mass_density); -QUANTITY_SPEC(surface_tension, force / length, quantity_character::scalar); // TODO what is a correct equation here? -QUANTITY_SPEC(power, mass* pow<2>(length) / pow<3>(time)); // not in ISO 80000 -QUANTITY_SPEC(mechanical_power, power, force* velocity, quantity_character::scalar); +QUANTITY_SPEC(surface_tension, force / length, + quantity_character::real_scalar); // TODO what is a correct equation here? +QUANTITY_SPEC(power, mass* pow<2>(length) / pow<3>(time)); // not in ISO 80000 +QUANTITY_SPEC(mechanical_power, power, force* velocity, quantity_character::real_scalar); QUANTITY_SPEC(mechanical_energy, energy); // differs from ISO 80000 QUANTITY_SPEC(potential_energy, mechanical_energy); // differs from ISO 80000 QUANTITY_SPEC(kinetic_energy, mechanical_energy, mass* pow<2>(speed)); // differs from ISO 80000 -QUANTITY_SPEC(mechanical_work, force* displacement, quantity_character::scalar); +QUANTITY_SPEC(mechanical_work, force* displacement, quantity_character::real_scalar); inline constexpr auto work = mechanical_work; QUANTITY_SPEC(mechanical_efficiency, mechanical_power / mechanical_power); QUANTITY_SPEC(mass_flow, mass_density* velocity); // vector -QUANTITY_SPEC(mass_flow_rate, mass_flow* area, quantity_character::scalar); +QUANTITY_SPEC(mass_flow_rate, mass_flow* area, quantity_character::real_scalar); QUANTITY_SPEC(mass_change_rate, mass / time); -QUANTITY_SPEC(volume_flow_rate, velocity* area, quantity_character::scalar); +QUANTITY_SPEC(volume_flow_rate, velocity* area, quantity_character::real_scalar); QUANTITY_SPEC(action, energy* time); } // namespace mp_units::isq diff --git a/src/systems/include/mp-units/systems/isq_angle.h b/src/systems/include/mp-units/systems/isq_angle.h index bf306d93..7e23cfdc 100644 --- a/src/systems/include/mp-units/systems/isq_angle.h +++ b/src/systems/include/mp-units/systems/isq_angle.h @@ -57,7 +57,7 @@ QUANTITY_SPEC(propagation_coefficient, cotes_angle_constant / length); QUANTITY_SPEC(angular_momentum, position_vector* momentum / cotes_angle_constant); // vector QUANTITY_SPEC(moment_of_inertia, angular_momentum / angular_velocity, quantity_character::tensor); QUANTITY_SPEC(moment_of_force, position_vector* force / cotes_angle_constant); // vector -QUANTITY_SPEC(torque, moment_of_force, quantity_character::scalar); +QUANTITY_SPEC(torque, moment_of_force, quantity_character::real_scalar); QUANTITY_SPEC(angular_impulse, moment_of_force* time); // vector QUANTITY_SPEC(loss_angle, angular_measure); diff --git a/test/runtime/linear_algebra_test.cpp b/test/runtime/linear_algebra_test.cpp index 200bf644..40023a11 100644 --- a/test/runtime/linear_algebra_test.cpp +++ b/test/runtime/linear_algebra_test.cpp @@ -60,7 +60,8 @@ using namespace mp_units; using namespace mp_units::si::unit_symbols; template Q> - requires(Q::quantity_spec.character == quantity_character::vector) && (QS.character == quantity_character::scalar) + requires(Q::quantity_spec.character == quantity_character::vector) && + (QS.character == quantity_character::real_scalar) [[nodiscard]] constexpr QuantityOf auto get_magnitude(const Q& q) { const auto& v = q.numerical_value_ref_in(q.unit); @@ -68,7 +69,8 @@ template Q> } template T> - requires(T::quantity_spec.character == quantity_character::vector) && (QS.character == quantity_character::scalar) + requires(T::quantity_spec.character == quantity_character::vector) && + (QS.character == quantity_character::real_scalar) [[nodiscard]] constexpr QuantityOf auto get_magnitude(const vector& v) { return hypot(QS(v(0)), QS(v(1)), QS(v(2))); diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp index 268d19cc..7f1ccf10 100644 --- a/test/static/concepts_test.cpp +++ b/test/static/concepts_test.cpp @@ -25,7 +25,6 @@ #include #if MP_UNITS_HOSTED #include -#include #endif #ifdef MP_UNITS_IMPORT_STD import std; @@ -331,30 +330,46 @@ static_assert(!Representation); #endif // RepresentationOf -static_assert(RepresentationOf); -static_assert(!RepresentationOf); +static_assert(RepresentationOf); +static_assert(!RepresentationOf); +static_assert(!RepresentationOf); static_assert(RepresentationOf); static_assert(!RepresentationOf); -static_assert(RepresentationOf); -static_assert(!RepresentationOf); + +static_assert(RepresentationOf); +static_assert(!RepresentationOf); +static_assert(!RepresentationOf); static_assert(RepresentationOf); static_assert(!RepresentationOf); -static_assert(!RepresentationOf); -static_assert(!RepresentationOf); + +static_assert(!RepresentationOf); +static_assert(!RepresentationOf); +static_assert(!RepresentationOf); static_assert(!RepresentationOf); static_assert(!RepresentationOf); -static_assert(!RepresentationOf, quantity_character::scalar>); + +static_assert(!RepresentationOf, quantity_character::real_scalar>); + #if MP_UNITS_HOSTED -static_assert(RepresentationOf, quantity_character::complex>); -static_assert(!RepresentationOf, quantity_character::scalar>); +static_assert(!RepresentationOf, quantity_character::real_scalar>); +static_assert(RepresentationOf, quantity_character::complex_scalar>); static_assert(!RepresentationOf, quantity_character::vector>); static_assert(!RepresentationOf, quantity_character::tensor>); + +static_assert(!RepresentationOf, quantity_character::real_scalar>); +static_assert(!RepresentationOf, quantity_character::complex_scalar>); static_assert(RepresentationOf, quantity_character::vector>); -static_assert(!RepresentationOf, quantity_character::scalar>); -static_assert(!RepresentationOf, quantity_character::complex>); +static_assert(!RepresentationOf, quantity_character::complex_scalar>); static_assert(!RepresentationOf, quantity_character::tensor>); -static_assert(!RepresentationOf); -static_assert(!RepresentationOf); + +static_assert(!RepresentationOf>, quantity_character::real_scalar>); +static_assert(!RepresentationOf>, quantity_character::complex_scalar>); +static_assert(RepresentationOf>, quantity_character::vector>); +static_assert(!RepresentationOf>, quantity_character::complex_scalar>); +static_assert(!RepresentationOf>, quantity_character::tensor>); + +static_assert(!RepresentationOf); +static_assert(!RepresentationOf); #endif // Quantity diff --git a/test/static/isq_angle_test.cpp b/test/static/isq_angle_test.cpp index 3c4cd372..9eade946 100644 --- a/test/static/isq_angle_test.cpp +++ b/test/static/isq_angle_test.cpp @@ -37,24 +37,24 @@ using enum mp_units::quantity_character; return q.character == ch && (... && requires { q[units]; }); } -static_assert(verify(isq_angle::cotes_angle_constant, scalar, rad)); -static_assert(verify(isq_angle::angular_measure, scalar, rad)); -static_assert(verify(isq_angle::rotational_displacement, scalar, rad)); -static_assert(verify(isq_angle::angular_displacement, scalar, rad)); -static_assert(verify(isq_angle::solid_angular_measure, scalar, sr)); +static_assert(verify(isq_angle::cotes_angle_constant, real_scalar, rad)); +static_assert(verify(isq_angle::angular_measure, real_scalar, rad)); +static_assert(verify(isq_angle::rotational_displacement, real_scalar, rad)); +static_assert(verify(isq_angle::angular_displacement, real_scalar, rad)); +static_assert(verify(isq_angle::solid_angular_measure, real_scalar, sr)); static_assert(verify(isq_angle::angular_velocity, vector, rad / s)); static_assert(verify(isq_angle::angular_acceleration, vector, rad / s2)); -static_assert(verify(isq_angle::rotation, scalar, rad)); -static_assert(verify(isq_angle::angular_frequency, scalar, rad / s)); -static_assert(verify(isq_angle::angular_repetency, scalar, rad / m)); -static_assert(verify(isq_angle::angular_wavenumber, scalar, rad / m)); -static_assert(verify(isq_angle::phase_coefficient, scalar, rad / m)); -static_assert(verify(isq_angle::propagation_coefficient, scalar, rad / m)); +static_assert(verify(isq_angle::rotation, real_scalar, rad)); +static_assert(verify(isq_angle::angular_frequency, real_scalar, rad / s)); +static_assert(verify(isq_angle::angular_repetency, real_scalar, rad / m)); +static_assert(verify(isq_angle::angular_wavenumber, real_scalar, rad / m)); +static_assert(verify(isq_angle::phase_coefficient, real_scalar, rad / m)); +static_assert(verify(isq_angle::propagation_coefficient, real_scalar, rad / m)); static_assert(verify(isq_angle::moment_of_inertia, tensor, kg* m2 / rad2)); static_assert(verify(isq_angle::angular_momentum, vector, J* s / rad)); static_assert(verify(isq_angle::moment_of_force, vector, J / rad)); -static_assert(verify(isq_angle::torque, scalar, J / rad)); +static_assert(verify(isq_angle::torque, real_scalar, J / rad)); static_assert(verify(isq_angle::angular_impulse, vector, J* s / rad)); -static_assert(verify(isq_angle::loss_angle, scalar, rad)); +static_assert(verify(isq_angle::loss_angle, real_scalar, rad)); } // namespace diff --git a/test/static/isq_test.cpp b/test/static/isq_test.cpp index 383d4a04..5933eaf0 100644 --- a/test/static/isq_test.cpp +++ b/test/static/isq_test.cpp @@ -38,69 +38,69 @@ using enum mp_units::quantity_character; } // space and time -static_assert(verify(isq::length, scalar, m)); -static_assert(verify(isq::width, scalar, m)); -static_assert(verify(isq::breadth, scalar, m)); -static_assert(verify(isq::height, scalar, m)); -static_assert(verify(isq::depth, scalar, m)); -static_assert(verify(isq::altitude, scalar, m)); -static_assert(verify(isq::thickness, scalar, m)); -static_assert(verify(isq::diameter, scalar, m)); -static_assert(verify(isq::radius, scalar, m)); -static_assert(verify(isq::path_length, scalar, m)); -static_assert(verify(isq::arc_length, scalar, m)); -static_assert(verify(isq::distance, scalar, m)); -static_assert(verify(isq::radial_distance, scalar, m)); +static_assert(verify(isq::length, real_scalar, m)); +static_assert(verify(isq::width, real_scalar, m)); +static_assert(verify(isq::breadth, real_scalar, m)); +static_assert(verify(isq::height, real_scalar, m)); +static_assert(verify(isq::depth, real_scalar, m)); +static_assert(verify(isq::altitude, real_scalar, m)); +static_assert(verify(isq::thickness, real_scalar, m)); +static_assert(verify(isq::diameter, real_scalar, m)); +static_assert(verify(isq::radius, real_scalar, m)); +static_assert(verify(isq::path_length, real_scalar, m)); +static_assert(verify(isq::arc_length, real_scalar, m)); +static_assert(verify(isq::distance, real_scalar, m)); +static_assert(verify(isq::radial_distance, real_scalar, m)); static_assert(verify(isq::position_vector, vector, m)); static_assert(verify(isq::displacement, vector, m)); -static_assert(verify(isq::radius_of_curvature, scalar, m)); -static_assert(verify(isq::curvature, scalar, one / m)); -static_assert(verify(isq::area, scalar, m2)); -static_assert(verify(isq::volume, scalar, m3)); -static_assert(verify(isq::angular_measure, scalar, rad, one)); -static_assert(verify(isq::rotational_displacement, scalar, rad, one)); -static_assert(verify(isq::angular_displacement, scalar, rad, one)); -static_assert(verify(isq::phase_angle, scalar, rad, one)); -static_assert(verify(isq::solid_angular_measure, scalar, sr, one)); -static_assert(verify(isq::duration, scalar, s)); +static_assert(verify(isq::radius_of_curvature, real_scalar, m)); +static_assert(verify(isq::curvature, real_scalar, one / m)); +static_assert(verify(isq::area, real_scalar, m2)); +static_assert(verify(isq::volume, real_scalar, m3)); +static_assert(verify(isq::angular_measure, real_scalar, rad, one)); +static_assert(verify(isq::rotational_displacement, real_scalar, rad, one)); +static_assert(verify(isq::angular_displacement, real_scalar, rad, one)); +static_assert(verify(isq::phase_angle, real_scalar, rad, one)); +static_assert(verify(isq::solid_angular_measure, real_scalar, sr, one)); +static_assert(verify(isq::duration, real_scalar, s)); static_assert(verify(isq::velocity, vector, m / s)); -static_assert(verify(isq::speed, scalar, m / s)); +static_assert(verify(isq::speed, real_scalar, m / s)); static_assert(verify(isq::acceleration, vector, m / s2)); static_assert(verify(isq::angular_velocity, vector, rad / s, one / s)); static_assert(verify(isq::angular_acceleration, vector, rad / s2, one / s2)); -static_assert(verify(isq::period_duration, scalar, s)); -static_assert(verify(isq::duration, scalar, s)); -static_assert(verify(isq::time_constant, scalar, s)); -static_assert(verify(isq::rotation, scalar, one)); -static_assert(verify(isq::frequency, scalar, Hz, one / s)); -static_assert(verify(isq::rotational_frequency, scalar, one / s)); -static_assert(verify(isq::angular_frequency, scalar, rad / s, one / s)); -static_assert(verify(isq::wavelength, scalar, m)); -static_assert(verify(isq::repetency, scalar, one / m)); -static_assert(verify(isq::wavenumber, scalar, one / m)); +static_assert(verify(isq::period_duration, real_scalar, s)); +static_assert(verify(isq::duration, real_scalar, s)); +static_assert(verify(isq::time_constant, real_scalar, s)); +static_assert(verify(isq::rotation, real_scalar, one)); +static_assert(verify(isq::frequency, real_scalar, Hz, one / s)); +static_assert(verify(isq::rotational_frequency, real_scalar, one / s)); +static_assert(verify(isq::angular_frequency, real_scalar, rad / s, one / s)); +static_assert(verify(isq::wavelength, real_scalar, m)); +static_assert(verify(isq::repetency, real_scalar, one / m)); +static_assert(verify(isq::wavenumber, real_scalar, one / m)); static_assert(verify(isq::wave_vector, vector, one / m)); -static_assert(verify(isq::angular_repetency, scalar, one / m)); -static_assert(verify(isq::angular_wavenumber, scalar, one / m)); -static_assert(verify(isq::phase_speed, scalar, m / s)); -static_assert(verify(isq::group_speed, scalar, m / s)); -static_assert(verify(isq::damping_coefficient, scalar, one / s)); -static_assert(verify(isq::logarithmic_decrement, scalar, one)); -static_assert(verify(isq::attenuation, scalar, one / m)); -static_assert(verify(isq::extinction, scalar, one / m)); -static_assert(verify(isq::phase_coefficient, scalar, rad / m, one / m)); -static_assert(verify(isq::propagation_coefficient, scalar, one / m)); +static_assert(verify(isq::angular_repetency, real_scalar, one / m)); +static_assert(verify(isq::angular_wavenumber, real_scalar, one / m)); +static_assert(verify(isq::phase_speed, real_scalar, m / s)); +static_assert(verify(isq::group_speed, real_scalar, m / s)); +static_assert(verify(isq::damping_coefficient, real_scalar, one / s)); +static_assert(verify(isq::logarithmic_decrement, real_scalar, one)); +static_assert(verify(isq::attenuation, real_scalar, one / m)); +static_assert(verify(isq::extinction, real_scalar, one / m)); +static_assert(verify(isq::phase_coefficient, real_scalar, rad / m, one / m)); +static_assert(verify(isq::propagation_coefficient, real_scalar, one / m)); // mechanics -static_assert(verify(isq::mass, scalar, kg)); -static_assert(verify(isq::mass_density, scalar, kg / m3)); -static_assert(verify(isq::density, scalar, kg / m3)); -static_assert(verify(isq::specific_volume, scalar, m3 / kg)); -static_assert(verify(isq::relative_mass_density, scalar, one)); -static_assert(verify(isq::relative_density, scalar, one)); -static_assert(verify(isq::surface_mass_density, scalar, kg / m2)); -static_assert(verify(isq::surface_density, scalar, kg / m2)); -static_assert(verify(isq::linear_mass_density, scalar, kg / m)); -static_assert(verify(isq::linear_density, scalar, kg / m)); +static_assert(verify(isq::mass, real_scalar, kg)); +static_assert(verify(isq::mass_density, real_scalar, kg / m3)); +static_assert(verify(isq::density, real_scalar, kg / m3)); +static_assert(verify(isq::specific_volume, real_scalar, m3 / kg)); +static_assert(verify(isq::relative_mass_density, real_scalar, one)); +static_assert(verify(isq::relative_density, real_scalar, one)); +static_assert(verify(isq::surface_mass_density, real_scalar, kg / m2)); +static_assert(verify(isq::surface_density, real_scalar, kg / m2)); +static_assert(verify(isq::linear_mass_density, real_scalar, kg / m)); +static_assert(verify(isq::linear_density, real_scalar, kg / m)); static_assert(verify(isq::moment_of_inertia, tensor, kg* m2)); static_assert(verify(isq::momentum, vector, kg* m / s)); static_assert(verify(isq::force, vector, N, kg* m / s2)); @@ -116,285 +116,286 @@ static_assert(verify(isq::drag_force, vector, N, kg* m / s2)); static_assert(verify(isq::impulse, vector, N* s, kg* m / s)); static_assert(verify(isq::angular_momentum, vector, kg* m2 / s)); static_assert(verify(isq::moment_of_force, vector, N* m, kg* m2 / s2)); -static_assert(verify(isq::torque, scalar, N* m, kg* m2 / s2)); +static_assert(verify(isq::torque, real_scalar, N* m, kg* m2 / s2)); static_assert(verify(isq::angular_impulse, vector, N* m* s, kg* m2 / s)); -static_assert(verify(isq::pressure, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::gauge_pressure, scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::pressure, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::gauge_pressure, real_scalar, Pa, N / m2, kg / m / s2)); static_assert(verify(isq::stress, tensor, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::normal_stress, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::shear_stress, scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::normal_stress, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::shear_stress, real_scalar, Pa, N / m2, kg / m / s2)); static_assert(verify(isq::strain, tensor, one)); -static_assert(verify(isq::relative_linear_strain, scalar, one)); -static_assert(verify(isq::shear_strain, scalar, one)); -static_assert(verify(isq::relative_volume_strain, scalar, one)); -static_assert(verify(isq::Poisson_number, scalar, one)); -static_assert(verify(isq::modulus_of_elasticity, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::Young_modulus, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::modulus_of_rigidity, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::shear_modulus, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::modulus_of_compression, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::bulk_modulus, scalar, Pa, N / m2, kg / m / s2)); -static_assert(verify(isq::compressibility, scalar, one / Pa, m* s2 / kg)); -static_assert(verify(isq::second_axial_moment_of_area, scalar, m4)); -static_assert(verify(isq::second_polar_moment_of_area, scalar, m4)); -static_assert(verify(isq::section_modulus, scalar, m3)); -static_assert(verify(isq::static_friction_coefficient, scalar, one)); -static_assert(verify(isq::static_friction_factor, scalar, one)); -static_assert(verify(isq::coefficient_of_static_friction, scalar, one)); -static_assert(verify(isq::kinetic_friction_factor, scalar, one)); -static_assert(verify(isq::dynamic_friction_factor, scalar, one)); -static_assert(verify(isq::rolling_resistance_factor, scalar, one)); -static_assert(verify(isq::drag_coefficient, scalar, one)); -static_assert(verify(isq::drag_factor, scalar, one)); -static_assert(verify(isq::dynamic_viscosity, scalar, Pa* s, kg / m / s)); -static_assert(verify(isq::kinematic_viscosity, scalar, m2 / s)); -static_assert(verify(isq::surface_tension, scalar, N / m, kg / s2)); -static_assert(verify(isq::power, scalar, W, N* m / s, kg* m2 / s3)); -static_assert(verify(isq::potential_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::kinetic_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::mechanical_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::mechanical_work, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::work, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::mechanical_efficiency, scalar, one)); +static_assert(verify(isq::relative_linear_strain, real_scalar, one)); +static_assert(verify(isq::shear_strain, real_scalar, one)); +static_assert(verify(isq::relative_volume_strain, real_scalar, one)); +static_assert(verify(isq::Poisson_number, real_scalar, one)); +static_assert(verify(isq::modulus_of_elasticity, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::Young_modulus, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::modulus_of_rigidity, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::shear_modulus, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::modulus_of_compression, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::bulk_modulus, real_scalar, Pa, N / m2, kg / m / s2)); +static_assert(verify(isq::compressibility, real_scalar, one / Pa, m* s2 / kg)); +static_assert(verify(isq::second_axial_moment_of_area, real_scalar, m4)); +static_assert(verify(isq::second_polar_moment_of_area, real_scalar, m4)); +static_assert(verify(isq::section_modulus, real_scalar, m3)); +static_assert(verify(isq::static_friction_coefficient, real_scalar, one)); +static_assert(verify(isq::static_friction_factor, real_scalar, one)); +static_assert(verify(isq::coefficient_of_static_friction, real_scalar, one)); +static_assert(verify(isq::kinetic_friction_factor, real_scalar, one)); +static_assert(verify(isq::dynamic_friction_factor, real_scalar, one)); +static_assert(verify(isq::rolling_resistance_factor, real_scalar, one)); +static_assert(verify(isq::drag_coefficient, real_scalar, one)); +static_assert(verify(isq::drag_factor, real_scalar, one)); +static_assert(verify(isq::dynamic_viscosity, real_scalar, Pa* s, kg / m / s)); +static_assert(verify(isq::kinematic_viscosity, real_scalar, m2 / s)); +static_assert(verify(isq::surface_tension, real_scalar, N / m, kg / s2)); +static_assert(verify(isq::power, real_scalar, W, N* m / s, kg* m2 / s3)); +static_assert(verify(isq::potential_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::kinetic_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::mechanical_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::mechanical_work, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::work, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::mechanical_efficiency, real_scalar, one)); static_assert(verify(isq::mass_flow, vector, kg / m2 / s)); -static_assert(verify(isq::mass_flow_rate, scalar, kg / s)); -static_assert(verify(isq::mass_change_rate, scalar, kg / s)); -static_assert(verify(isq::volume_flow_rate, scalar, m3 / s)); -static_assert(verify(isq::action, scalar, J* s, kg* m2 / s)); +static_assert(verify(isq::mass_flow_rate, real_scalar, kg / s)); +static_assert(verify(isq::mass_change_rate, real_scalar, kg / s)); +static_assert(verify(isq::volume_flow_rate, real_scalar, m3 / s)); +static_assert(verify(isq::action, real_scalar, J* s, kg* m2 / s)); // thermodynamics -static_assert(verify(isq::thermodynamic_temperature, scalar, K)); -static_assert(verify(isq::Celsius_temperature, scalar, deg_C)); -static_assert(verify(isq::linear_expansion_coefficient, scalar, one / K)); -static_assert(verify(isq::cubic_expansion_coefficient, scalar, one / K)); -static_assert(verify(isq::relative_pressure_coefficient, scalar, one / K)); -static_assert(verify(isq::pressure_coefficient, scalar, Pa / K, kg / m / s2 / K)); -static_assert(verify(isq::isothermal_compressibility, scalar, one / Pa, m* s2 / kg)); -static_assert(verify(isq::isentropic_compressibility, scalar, one / Pa, m* s2 / kg)); -static_assert(verify(isq::heat, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::amount_of_heat, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::latent_heat, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::heat_flow_rate, scalar, W, J / s, kg* m2 / s3)); -static_assert(verify(isq::density_of_heat_flow_rate, scalar, W / m2, kg / s3)); -static_assert(verify(isq::thermal_conductivity, scalar, W / (m * K), kg* m / s3 / K)); -static_assert(verify(isq::coefficient_of_heat_transfer, scalar, W / (m2 * K), kg / s3 / K)); -static_assert(verify(isq::surface_coefficient_of_heat_transfer, scalar, W / (m2 * K), kg / s3 / K)); -static_assert(verify(isq::thermal_insulance, scalar, m2* K / W, s3* K / kg)); -static_assert(verify(isq::thermal_resistance, scalar, K / W, s3* K / kg / m2)); -static_assert(verify(isq::thermal_conductance, scalar, W / K, kg* m2 / s3 / K)); -static_assert(verify(isq::thermal_diffusivity, scalar, m2 / s)); -static_assert(verify(isq::heat_capacity, scalar, J / K, kg* m2 / s2 / K)); -static_assert(verify(isq::specific_heat_capacity, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::specific_heat_capacity_at_constant_pressure, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::specific_heat_capacity_at_constant_volume, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::specific_heat_capacity_at_saturated_vapour_pressure, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::ratio_of_specific_heat_capacities, scalar, one)); -static_assert(verify(isq::isentropic_exponent, scalar, one)); -static_assert(verify(isq::isentropic_expansion_factor, scalar, one)); -static_assert(verify(isq::entropy, scalar, J / K, kg* m2 / s2 / K)); -static_assert(verify(isq::specific_entropy, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::internal_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::thermodynamic_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::enthalpy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::Helmholtz_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::Helmholtz_function, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::Gibbs_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::Gibbs_function, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::specific_energy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_internal_energy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_thermodynamic_energy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_enthalpy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_Helmholtz_energy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_Helmholtz_function, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_Gibbs_energy, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::specific_Gibbs_function, scalar, J / kg, m2 / s2)); -static_assert(verify(isq::Massieu_function, scalar, J / K, kg* m2 / s2 / K)); -static_assert(verify(isq::Planck_function, scalar, J / K, kg* m2 / s2 / K)); -static_assert(verify(isq::Joule_Thomson_coefficient, scalar, K / Pa, m* s2* K / kg)); -static_assert(verify(isq::thermodynamic_efficiency, scalar, one)); -static_assert(verify(isq::maximum_efficiency, scalar, one)); -static_assert(verify(isq::specific_gas_constant, scalar, J / (kg * K), m2 / s2 / K)); -static_assert(verify(isq::mass_concentration_of_water, scalar, kg / m3)); -static_assert(verify(isq::mass_concentration_of_water_vapour, scalar, kg / m3)); -static_assert(verify(isq::mass_ratio_of_water_to_dry_matter, scalar, one)); -static_assert(verify(isq::mass_ratio_of_water_vapour_to_dry_gas, scalar, one)); -static_assert(verify(isq::mass_fraction_of_water, scalar, one)); -static_assert(verify(isq::mass_fraction_of_dry_matter, scalar, one)); -static_assert(verify(isq::relative_humidity, scalar, one)); -static_assert(verify(isq::relative_mass_concentration_of_vapour, scalar, one)); -static_assert(verify(isq::relative_mass_ratio_of_vapour, scalar, one)); -static_assert(verify(isq::dew_point_temperature, scalar, K)); +static_assert(verify(isq::thermodynamic_temperature, real_scalar, K)); +static_assert(verify(isq::Celsius_temperature, real_scalar, deg_C)); +static_assert(verify(isq::linear_expansion_coefficient, real_scalar, one / K)); +static_assert(verify(isq::cubic_expansion_coefficient, real_scalar, one / K)); +static_assert(verify(isq::relative_pressure_coefficient, real_scalar, one / K)); +static_assert(verify(isq::pressure_coefficient, real_scalar, Pa / K, kg / m / s2 / K)); +static_assert(verify(isq::isothermal_compressibility, real_scalar, one / Pa, m* s2 / kg)); +static_assert(verify(isq::isentropic_compressibility, real_scalar, one / Pa, m* s2 / kg)); +static_assert(verify(isq::heat, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::amount_of_heat, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::latent_heat, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::heat_flow_rate, real_scalar, W, J / s, kg* m2 / s3)); +static_assert(verify(isq::density_of_heat_flow_rate, real_scalar, W / m2, kg / s3)); +static_assert(verify(isq::thermal_conductivity, real_scalar, W / (m * K), kg* m / s3 / K)); +static_assert(verify(isq::coefficient_of_heat_transfer, real_scalar, W / (m2 * K), kg / s3 / K)); +static_assert(verify(isq::surface_coefficient_of_heat_transfer, real_scalar, W / (m2 * K), kg / s3 / K)); +static_assert(verify(isq::thermal_insulance, real_scalar, m2* K / W, s3* K / kg)); +static_assert(verify(isq::thermal_resistance, real_scalar, K / W, s3* K / kg / m2)); +static_assert(verify(isq::thermal_conductance, real_scalar, W / K, kg* m2 / s3 / K)); +static_assert(verify(isq::thermal_diffusivity, real_scalar, m2 / s)); +static_assert(verify(isq::heat_capacity, real_scalar, J / K, kg* m2 / s2 / K)); +static_assert(verify(isq::specific_heat_capacity, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::specific_heat_capacity_at_constant_pressure, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::specific_heat_capacity_at_constant_volume, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::specific_heat_capacity_at_saturated_vapour_pressure, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::ratio_of_specific_heat_capacities, real_scalar, one)); +static_assert(verify(isq::isentropic_exponent, real_scalar, one)); +static_assert(verify(isq::isentropic_expansion_factor, real_scalar, one)); +static_assert(verify(isq::entropy, real_scalar, J / K, kg* m2 / s2 / K)); +static_assert(verify(isq::specific_entropy, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::internal_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::thermodynamic_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::enthalpy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::Helmholtz_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::Helmholtz_function, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::Gibbs_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::Gibbs_function, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::specific_energy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_internal_energy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_thermodynamic_energy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_enthalpy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_Helmholtz_energy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_Helmholtz_function, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_Gibbs_energy, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::specific_Gibbs_function, real_scalar, J / kg, m2 / s2)); +static_assert(verify(isq::Massieu_function, real_scalar, J / K, kg* m2 / s2 / K)); +static_assert(verify(isq::Planck_function, real_scalar, J / K, kg* m2 / s2 / K)); +static_assert(verify(isq::Joule_Thomson_coefficient, real_scalar, K / Pa, m* s2* K / kg)); +static_assert(verify(isq::thermodynamic_efficiency, real_scalar, one)); +static_assert(verify(isq::maximum_efficiency, real_scalar, one)); +static_assert(verify(isq::specific_gas_constant, real_scalar, J / (kg * K), m2 / s2 / K)); +static_assert(verify(isq::mass_concentration_of_water, real_scalar, kg / m3)); +static_assert(verify(isq::mass_concentration_of_water_vapour, real_scalar, kg / m3)); +static_assert(verify(isq::mass_ratio_of_water_to_dry_matter, real_scalar, one)); +static_assert(verify(isq::mass_ratio_of_water_vapour_to_dry_gas, real_scalar, one)); +static_assert(verify(isq::mass_fraction_of_water, real_scalar, one)); +static_assert(verify(isq::mass_fraction_of_dry_matter, real_scalar, one)); +static_assert(verify(isq::relative_humidity, real_scalar, one)); +static_assert(verify(isq::relative_mass_concentration_of_vapour, real_scalar, one)); +static_assert(verify(isq::relative_mass_ratio_of_vapour, real_scalar, one)); +static_assert(verify(isq::dew_point_temperature, real_scalar, K)); // electromagnetism -static_assert(verify(isq::electric_current, scalar, A)); -static_assert(verify(isq::electric_charge, scalar, C, A* s)); -static_assert(verify(isq::elementary_charge, scalar, C, A* s)); -static_assert(verify(isq::electric_charge_density, scalar, C / m3, s* A / m3)); -static_assert(verify(isq::volume_electric_charge, scalar, C / m3, s* A / m3)); -static_assert(verify(isq::volumic_charge, scalar, C / m3, s* A / m3)); -static_assert(verify(isq::surface_density_of_electric_charge, scalar, C / m2, s* A / m2)); -static_assert(verify(isq::areic_electric_charge, scalar, C / m2, s* A / m2)); -static_assert(verify(isq::areic_charge, scalar, C / m2, s* A / m2)); -static_assert(verify(isq::linear_density_of_electric_charge, scalar, C / m, s* A / m)); -static_assert(verify(isq::lineic_electric_charge, scalar, C / m, s* A / m)); -static_assert(verify(isq::lineic_charge, scalar, C / m, s* A / m)); +static_assert(verify(isq::electric_current, real_scalar, A)); +static_assert(verify(isq::electric_charge, real_scalar, C, A* s)); +static_assert(verify(isq::elementary_charge, real_scalar, C, A* s)); +static_assert(verify(isq::electric_charge_density, real_scalar, C / m3, s* A / m3)); +static_assert(verify(isq::volume_electric_charge, real_scalar, C / m3, s* A / m3)); +static_assert(verify(isq::volumic_charge, real_scalar, C / m3, s* A / m3)); +static_assert(verify(isq::surface_density_of_electric_charge, real_scalar, C / m2, s* A / m2)); +static_assert(verify(isq::areic_electric_charge, real_scalar, C / m2, s* A / m2)); +static_assert(verify(isq::areic_charge, real_scalar, C / m2, s* A / m2)); +static_assert(verify(isq::linear_density_of_electric_charge, real_scalar, C / m, s* A / m)); +static_assert(verify(isq::lineic_electric_charge, real_scalar, C / m, s* A / m)); +static_assert(verify(isq::lineic_charge, real_scalar, C / m, s* A / m)); static_assert(verify(isq::electric_dipole_moment, vector, C* m, m* s* A)); static_assert(verify(isq::electric_polarization, vector, C / m2, s* A / m2)); static_assert(verify(isq::electric_current_density, vector, A / m2)); static_assert(verify(isq::linear_electric_current_density, vector, A / m)); static_assert(verify(isq::electric_field_strength, vector, V / m, kg* m / (s3 * A))); -static_assert(verify(isq::electric_potential, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::electric_potential_difference, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::voltage, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::electric_tension, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::induced_voltage, scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::electric_potential, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::electric_potential_difference, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::voltage, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::electric_tension, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::induced_voltage, real_scalar, V, kg* m2 / (s3 * A))); static_assert(verify(isq::electric_flux_density, vector, C / m2, s* A / m2)); static_assert(verify(isq::electric_displacement, vector, C / m2, s* A / m2)); -static_assert(verify(isq::capacitance, scalar, F, pow<4>(s) * square(A) / (kg * m2))); -static_assert(verify(isq::electric_constant, scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); -static_assert(verify(isq::permittivity_of_vacuum, scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); -static_assert(verify(isq::permittivity, scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); -static_assert(verify(isq::relative_permittivity, scalar, one)); -static_assert(verify(isq::electric_susceptibility, scalar, one)); -static_assert(verify(isq::electric_flux, scalar, C, s* A)); +static_assert(verify(isq::capacitance, real_scalar, F, pow<4>(s) * square(A) / (kg * m2))); +static_assert(verify(isq::electric_constant, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); +static_assert(verify(isq::permittivity_of_vacuum, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); +static_assert(verify(isq::permittivity, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3))); +static_assert(verify(isq::relative_permittivity, real_scalar, one)); +static_assert(verify(isq::electric_susceptibility, real_scalar, one)); +static_assert(verify(isq::electric_flux, real_scalar, C, s* A)); static_assert(verify(isq::displacement_current_density, vector, A / m2)); -static_assert(verify(isq::displacement_current, scalar, A)); -static_assert(verify(isq::total_current, scalar, A)); +static_assert(verify(isq::displacement_current, real_scalar, A)); +static_assert(verify(isq::total_current, real_scalar, A)); static_assert(verify(isq::total_current_density, vector, A / m2)); static_assert(verify(isq::magnetic_flux_density, vector, T, kg / (s2 * A))); -static_assert(verify(isq::magnetic_flux, scalar, Wb, kg* m2 / (s2 * A))); -static_assert(verify(isq::protoflux, scalar, Wb, kg* m2 / (s2 * A))); -static_assert(verify(isq::linked_magnetic_flux, scalar, Wb, kg* m2 / (s2 * A))); -static_assert(verify(isq::total_magnetic_flux, scalar, Wb, kg* m2 / (s2 * A))); +static_assert(verify(isq::magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A))); +static_assert(verify(isq::protoflux, real_scalar, Wb, kg* m2 / (s2 * A))); +static_assert(verify(isq::linked_magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A))); +static_assert(verify(isq::total_magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A))); static_assert(verify(isq::magnetic_moment, vector, A* m2)); static_assert(verify(isq::magnetic_area_moment, vector, A* m2)); static_assert(verify(isq::magnetization, vector, A / m)); static_assert(verify(isq::magnetic_field_strength, vector, A / m)); static_assert(verify(isq::magnetizing_field, vector, A / m)); -static_assert(verify(isq::magnetic_constant, scalar, H / m, kg* m / (s2 * square(A)))); -static_assert(verify(isq::permeability_of_vacuum, scalar, H / m, kg* m / (s2 * square(A)))); -static_assert(verify(isq::permeability, scalar, H / m, kg* m / (s2 * square(A)))); -static_assert(verify(isq::relative_permeability, scalar, one)); -static_assert(verify(isq::magnetic_susceptibility, scalar, one)); +static_assert(verify(isq::magnetic_constant, real_scalar, H / m, kg* m / (s2 * square(A)))); +static_assert(verify(isq::permeability_of_vacuum, real_scalar, H / m, kg* m / (s2 * square(A)))); +static_assert(verify(isq::permeability, real_scalar, H / m, kg* m / (s2 * square(A)))); +static_assert(verify(isq::relative_permeability, real_scalar, one)); +static_assert(verify(isq::magnetic_susceptibility, real_scalar, one)); static_assert(verify(isq::magnetic_polarization, vector, T, Wb / m2, kg / (s2 * A))); static_assert(verify(isq::magnetic_dipole_moment, vector, Wb* m, kg* m3 / (s2 * A))); -static_assert(verify(isq::coercivity, scalar, A / m)); -static_assert(verify(isq::coercive_field_strength, scalar, A / m)); +static_assert(verify(isq::coercivity, real_scalar, A / m)); +static_assert(verify(isq::coercive_field_strength, real_scalar, A / m)); static_assert(verify(isq::magnetic_vector_potential, vector, J / (A * m), kg* m / (s2 * A))); -static_assert(verify(isq::electromagnetic_energy_density, scalar, J / m3, kg / (m * s2))); +static_assert(verify(isq::electromagnetic_energy_density, real_scalar, J / m3, kg / (m * s2))); static_assert(verify(isq::Poynting_vector, vector, W / m2, kg / s3)); -static_assert(verify(isq::phase_speed_of_electromagnetic_waves, scalar, m / s)); -static_assert(verify(isq::speed_of_light_in_vacuum, scalar, m / s)); -static_assert(verify(isq::light_speed_in_vacuum, scalar, m / s)); -static_assert(verify(isq::luminal_speed, scalar, m / s)); -static_assert(verify(isq::source_voltage, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::source_tension, scalar, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::magnetic_potential, scalar, A)); -static_assert(verify(isq::magnetic_tension, scalar, A)); -static_assert(verify(isq::magnetomotive_force, scalar, A)); -static_assert(verify(isq::number_of_turns_in_a_winding, scalar, one)); -static_assert(verify(isq::reluctance, scalar, one / H, s2* square(A) / (kg * m2))); -static_assert(verify(isq::permeance, scalar, H, kg* m2 / (s2 * square(A)))); -static_assert(verify(isq::inductance, scalar, H, kg* m2 / (s2 * square(A)))); -static_assert(verify(isq::self_inductance, scalar, H, kg* m2 / (s2 * square(A)))); -static_assert(verify(isq::mutual_inductance, scalar, H, kg* m2 / (s2 * square(A)))); -static_assert(verify(isq::coupling_factor, scalar, one)); -static_assert(verify(isq::leakage_factor, scalar, one)); -static_assert(verify(isq::conductivity, scalar, S / m, s3* square(A) / (kg * m3))); -static_assert(verify(isq::resistivity, scalar, Ω* m, kg* m3 / (s3 * square(A)))); -static_assert(verify(isq::electromagnetism_power, scalar, W, kg* m2 / s3)); -static_assert(verify(isq::instantaneous_power, scalar, W, kg* m2 / s3)); -static_assert(verify(isq::resistance, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::conductance, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::phase_difference, scalar, rad, one)); -static_assert(verify(isq::electric_current_phasor, complex, A)); -static_assert(verify(isq::voltage_phasor, complex, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::electric_tension_phasor, complex, V, kg* m2 / (s3 * A))); -static_assert(verify(isq::impedance, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::complex_impedance, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::impedance_of_vacuum, scalar, V / A, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::wave_impedance_in_vacuum, scalar, V / A, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::resistance_to_alternating_current, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::reactance, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::apparent_impedance, scalar, Ω, kg* m2 / (s3 * square(A)))); -static_assert(verify(isq::admittance, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::complex_admittance, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::admittance_of_vacuum, scalar, A / V, s3* square(A) / (kg * m2))); -static_assert(verify(isq::conductance_for_alternating_current, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::susceptance, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::apparent_admittance, scalar, S, s3* square(A) / (kg * m2))); -static_assert(verify(isq::quality_factor, scalar, one)); -static_assert(verify(isq::loss_factor, scalar, one)); -static_assert(verify(isq::loss_angle, scalar, rad, one)); -static_assert(verify(isq::active_power, scalar, W, kg* m2 / s3)); -static_assert(verify(isq::apparent_power, scalar, V* A, kg* m2 / s3)); -static_assert(verify(isq::power_factor, scalar, one)); -static_assert(verify(isq::complex_power, complex, V* A, kg* m2 / s3)); -static_assert(verify(isq::reactive_power, scalar, var, V* A, kg* m2 / s3)); -static_assert(verify(isq::non_active_power, scalar, V* A, kg* m2 / s3)); -static_assert(verify(isq::active_energy, scalar, J, W* s, kg* m2 / s2)); +static_assert(verify(isq::phase_speed_of_electromagnetic_waves, real_scalar, m / s)); +static_assert(verify(isq::speed_of_light_in_vacuum, real_scalar, m / s)); +static_assert(verify(isq::light_speed_in_vacuum, real_scalar, m / s)); +static_assert(verify(isq::luminal_speed, real_scalar, m / s)); +static_assert(verify(isq::source_voltage, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::source_tension, real_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::magnetic_potential, real_scalar, A)); +static_assert(verify(isq::magnetic_tension, real_scalar, A)); +static_assert(verify(isq::magnetomotive_force, real_scalar, A)); +static_assert(verify(isq::number_of_turns_in_a_winding, real_scalar, one)); +static_assert(verify(isq::reluctance, real_scalar, one / H, s2* square(A) / (kg * m2))); +static_assert(verify(isq::permeance, real_scalar, H, kg* m2 / (s2 * square(A)))); +static_assert(verify(isq::inductance, real_scalar, H, kg* m2 / (s2 * square(A)))); +static_assert(verify(isq::self_inductance, real_scalar, H, kg* m2 / (s2 * square(A)))); +static_assert(verify(isq::mutual_inductance, real_scalar, H, kg* m2 / (s2 * square(A)))); +static_assert(verify(isq::coupling_factor, real_scalar, one)); +static_assert(verify(isq::leakage_factor, real_scalar, one)); +static_assert(verify(isq::conductivity, real_scalar, S / m, s3* square(A) / (kg * m3))); +static_assert(verify(isq::resistivity, real_scalar, Ω* m, kg* m3 / (s3 * square(A)))); +static_assert(verify(isq::electromagnetism_power, real_scalar, W, kg* m2 / s3)); +static_assert(verify(isq::instantaneous_power, real_scalar, W, kg* m2 / s3)); +static_assert(verify(isq::resistance, real_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::conductance, real_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::phase_difference, real_scalar, rad, one)); +static_assert(verify(isq::electric_current_phasor, complex_scalar, A)); +static_assert(verify(isq::voltage_phasor, complex_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::electric_tension_phasor, complex_scalar, V, kg* m2 / (s3 * A))); +static_assert(verify(isq::impedance, complex_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::complex_impedance, complex_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::impedance_of_vacuum, complex_scalar, V / A, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::wave_impedance_in_vacuum, complex_scalar, V / A, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::resistance_to_alternating_current, real_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::reactance, real_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::apparent_impedance, real_scalar, Ω, kg* m2 / (s3 * square(A)))); +static_assert(verify(isq::admittance, complex_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::complex_admittance, complex_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::admittance_of_vacuum, complex_scalar, A / V, s3* square(A) / (kg * m2))); +static_assert(verify(isq::conductance_for_alternating_current, real_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::susceptance, real_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::apparent_admittance, real_scalar, S, s3* square(A) / (kg * m2))); +static_assert(verify(isq::quality_factor, real_scalar, one)); +static_assert(verify(isq::loss_factor, real_scalar, one)); +static_assert(verify(isq::loss_angle, real_scalar, rad, one)); +static_assert(verify(isq::active_power, real_scalar, W, kg* m2 / s3)); +static_assert(verify(isq::apparent_power, real_scalar, V* A, kg* m2 / s3)); +static_assert(verify(isq::power_factor, real_scalar, one)); +static_assert(verify(isq::complex_power, complex_scalar, V* A, kg* m2 / s3)); +static_assert(verify(isq::reactive_power, real_scalar, var, V* A, kg* m2 / s3)); +static_assert(verify(isq::non_active_power, real_scalar, V* A, kg* m2 / s3)); +static_assert(verify(isq::active_energy, real_scalar, J, W* s, kg* m2 / s2)); // light and radiation -static_assert(verify(isq::speed_of_light_in_a_medium, scalar, m / s)); -static_assert(verify(isq::refractive_index, scalar, one)); -static_assert(verify(isq::radiant_energy, scalar, J, kg* m2 / s2)); -static_assert(verify(isq::spectral_radiant_energy, scalar, J / nm, kg* m / s2)); -static_assert(verify(isq::radiant_energy_density, scalar, J / m3, kg / m / s2)); -static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavelength, scalar, J / (m3 * nm), kg / m2 / s2)); -static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavenumber, scalar, J / m2, kg / s2)); -static_assert(verify(isq::radiant_flux, scalar, W, kg* m2 / s3)); -static_assert(verify(isq::radiant_power, scalar, W, kg* m2 / s3)); -static_assert(verify(isq::spectral_radiant_flux, scalar, W / nm, kg* m / s3)); -static_assert(verify(isq::spectral_radiant_power, scalar, W / nm, kg* m / s3)); -static_assert(verify(isq::radiant_intensity, scalar, W / sr, kg* m2 / s3 / sr)); -static_assert(verify(isq::spectral_radiant_intensity, scalar, W / (sr * nm), kg* m / s3 / sr)); -static_assert(verify(isq::radiance, scalar, W / (sr * m2), kg / s3 / sr)); -static_assert(verify(isq::spectral_radiance, scalar, W / (sr * m2 * nm), kg / m / s3 / sr)); -static_assert(verify(isq::irradiance, scalar, W / m2, kg / s3)); -static_assert(verify(isq::spectral_irradiance, scalar, W / (m2 * nm), kg / m / s3)); -static_assert(verify(isq::radiant_exitance, scalar, W / m2, kg / s3)); -static_assert(verify(isq::spectral_radiant_exitance, scalar, W / (m2 * nm), kg / m / s3)); -static_assert(verify(isq::radiant_exposure, scalar, J / m2, kg / s2)); -static_assert(verify(isq::spectral_radiant_exposure, scalar, J / (m2 * nm), kg / m / s2)); +static_assert(verify(isq::speed_of_light_in_a_medium, real_scalar, m / s)); +static_assert(verify(isq::refractive_index, real_scalar, one)); +static_assert(verify(isq::radiant_energy, real_scalar, J, kg* m2 / s2)); +static_assert(verify(isq::spectral_radiant_energy, real_scalar, J / nm, kg* m / s2)); +static_assert(verify(isq::radiant_energy_density, real_scalar, J / m3, kg / m / s2)); +static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavelength, real_scalar, J / (m3 * nm), + kg / m2 / s2)); +static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavenumber, real_scalar, J / m2, kg / s2)); +static_assert(verify(isq::radiant_flux, real_scalar, W, kg* m2 / s3)); +static_assert(verify(isq::radiant_power, real_scalar, W, kg* m2 / s3)); +static_assert(verify(isq::spectral_radiant_flux, real_scalar, W / nm, kg* m / s3)); +static_assert(verify(isq::spectral_radiant_power, real_scalar, W / nm, kg* m / s3)); +static_assert(verify(isq::radiant_intensity, real_scalar, W / sr, kg* m2 / s3 / sr)); +static_assert(verify(isq::spectral_radiant_intensity, real_scalar, W / (sr * nm), kg* m / s3 / sr)); +static_assert(verify(isq::radiance, real_scalar, W / (sr * m2), kg / s3 / sr)); +static_assert(verify(isq::spectral_radiance, real_scalar, W / (sr * m2 * nm), kg / m / s3 / sr)); +static_assert(verify(isq::irradiance, real_scalar, W / m2, kg / s3)); +static_assert(verify(isq::spectral_irradiance, real_scalar, W / (m2 * nm), kg / m / s3)); +static_assert(verify(isq::radiant_exitance, real_scalar, W / m2, kg / s3)); +static_assert(verify(isq::spectral_radiant_exitance, real_scalar, W / (m2 * nm), kg / m / s3)); +static_assert(verify(isq::radiant_exposure, real_scalar, J / m2, kg / s2)); +static_assert(verify(isq::spectral_radiant_exposure, real_scalar, J / (m2 * nm), kg / m / s2)); // atomic and nuclear physics -static_assert(verify(isq::activity, scalar, Bq, one / s)); -static_assert(verify(isq::absorbed_dose, scalar, Gy, J / kg, m2 / s2)); -static_assert(verify(isq::quality_factor, scalar, one)); -static_assert(verify(isq::dose_equivalent, scalar, Sv, J / kg, m2 / s2)); +static_assert(verify(isq::activity, real_scalar, Bq, one / s)); +static_assert(verify(isq::absorbed_dose, real_scalar, Gy, J / kg, m2 / s2)); +static_assert(verify(isq::quality_factor, real_scalar, one)); +static_assert(verify(isq::dose_equivalent, real_scalar, Sv, J / kg, m2 / s2)); // information science and technology -static_assert(verify(isq::traffic_intensity, scalar, E)); -static_assert(verify(isq::traffic_offered_intensity, scalar, E)); -static_assert(verify(isq::traffic_carried_intensity, scalar, E)); -static_assert(verify(isq::traffic_load, scalar, E)); -static_assert(verify(isq::mean_queue_length, scalar, one)); -static_assert(verify(isq::loss_probability, scalar, one)); -static_assert(verify(isq::waiting_probability, scalar, one)); -static_assert(verify(isq::call_intensity, scalar, one / s)); -static_assert(verify(isq::calling_rate, scalar, one / s)); -static_assert(verify(isq::completed_call_intensity, scalar, one / s)); -static_assert(verify(isq::storage_capacity, scalar, one, bit, o, B)); -static_assert(verify(isq::storage_size, scalar, one, bit, o, B)); -static_assert(verify(isq::equivalent_binary_storage_capacity, scalar, one, bit)); -static_assert(verify(isq::transfer_rate, scalar, one / s, o / s, B / s)); -static_assert(verify(isq::period_of_data_elements, scalar, s)); -static_assert(verify(isq::binary_digit_rate, scalar, one / s, bit / s)); -static_assert(verify(isq::bit_rate, scalar, one / s, bit / s)); -static_assert(verify(isq::period_of_binary_digits, scalar, s)); -static_assert(verify(isq::bit_period, scalar, s)); -static_assert(verify(isq::equivalent_binary_digit_rate, scalar, one / s, bit / s)); -static_assert(verify(isq::equivalent_bit_rate, scalar, one / s, bit / s)); -static_assert(verify(isq::modulation_rate, scalar, one / s, Bd)); -static_assert(verify(isq::line_digit_rate, scalar, one / s, Bd)); -static_assert(verify(isq::quantizing_distortion_power, scalar, W)); -static_assert(verify(isq::carrier_power, scalar, W)); -static_assert(verify(isq::signal_energy_per_binary_digit, scalar, J)); -static_assert(verify(isq::error_probability, scalar, one)); -static_assert(verify(isq::Hamming_distance, scalar, one)); -static_assert(verify(isq::clock_frequency, scalar, Hz)); -static_assert(verify(isq::clock_rate, scalar, Hz)); -static_assert(verify(isq::decision_content, scalar, one)); +static_assert(verify(isq::traffic_intensity, real_scalar, E)); +static_assert(verify(isq::traffic_offered_intensity, real_scalar, E)); +static_assert(verify(isq::traffic_carried_intensity, real_scalar, E)); +static_assert(verify(isq::traffic_load, real_scalar, E)); +static_assert(verify(isq::mean_queue_length, real_scalar, one)); +static_assert(verify(isq::loss_probability, real_scalar, one)); +static_assert(verify(isq::waiting_probability, real_scalar, one)); +static_assert(verify(isq::call_intensity, real_scalar, one / s)); +static_assert(verify(isq::calling_rate, real_scalar, one / s)); +static_assert(verify(isq::completed_call_intensity, real_scalar, one / s)); +static_assert(verify(isq::storage_capacity, real_scalar, one, bit, o, B)); +static_assert(verify(isq::storage_size, real_scalar, one, bit, o, B)); +static_assert(verify(isq::equivalent_binary_storage_capacity, real_scalar, one, bit)); +static_assert(verify(isq::transfer_rate, real_scalar, one / s, o / s, B / s)); +static_assert(verify(isq::period_of_data_elements, real_scalar, s)); +static_assert(verify(isq::binary_digit_rate, real_scalar, one / s, bit / s)); +static_assert(verify(isq::bit_rate, real_scalar, one / s, bit / s)); +static_assert(verify(isq::period_of_binary_digits, real_scalar, s)); +static_assert(verify(isq::bit_period, real_scalar, s)); +static_assert(verify(isq::equivalent_binary_digit_rate, real_scalar, one / s, bit / s)); +static_assert(verify(isq::equivalent_bit_rate, real_scalar, one / s, bit / s)); +static_assert(verify(isq::modulation_rate, real_scalar, one / s, Bd)); +static_assert(verify(isq::line_digit_rate, real_scalar, one / s, Bd)); +static_assert(verify(isq::quantizing_distortion_power, real_scalar, W)); +static_assert(verify(isq::carrier_power, real_scalar, W)); +static_assert(verify(isq::signal_energy_per_binary_digit, real_scalar, J)); +static_assert(verify(isq::error_probability, real_scalar, one)); +static_assert(verify(isq::Hamming_distance, real_scalar, one)); +static_assert(verify(isq::clock_frequency, real_scalar, Hz)); +static_assert(verify(isq::clock_rate, real_scalar, Hz)); +static_assert(verify(isq::decision_content, real_scalar, one)); } // namespace diff --git a/test/static/quantity_spec_test.cpp b/test/static/quantity_spec_test.cpp index 936a16a0..8ce0938e 100644 --- a/test/static/quantity_spec_test.cpp +++ b/test/static/quantity_spec_test.cpp @@ -86,11 +86,11 @@ QUANTITY_SPEC_(mass_density, mass / volume); QUANTITY_SPEC_(force, mass * acceleration); QUANTITY_SPEC_(weight, force, mass * acceleration_of_free_fall); QUANTITY_SPEC_(moment_of_force, position_vector* force); -QUANTITY_SPEC_(torque, moment_of_force, quantity_character::scalar); -QUANTITY_SPEC_(pressure, force / area, quantity_character::scalar); +QUANTITY_SPEC_(torque, moment_of_force, quantity_character::real_scalar); +QUANTITY_SPEC_(pressure, force / area, quantity_character::real_scalar); QUANTITY_SPEC_(stress, pressure, quantity_character::tensor); QUANTITY_SPEC_(strain, dimensionless, quantity_character::tensor); -QUANTITY_SPEC_(power, force* velocity, quantity_character::scalar); +QUANTITY_SPEC_(power, force* velocity, quantity_character::real_scalar); QUANTITY_SPEC_(efficiency, power / power); QUANTITY_SPEC_(energy, mass * pow<2>(length) / pow<2>(time)); QUANTITY_SPEC_(mechanical_energy, energy); @@ -100,14 +100,14 @@ QUANTITY_SPEC_(kinetic_energy, mechanical_energy, mass* pow<2>(speed)); QUANTITY_SPEC_(electric_current, dim_electric_current); QUANTITY_SPEC_(electric_charge, electric_current* time); QUANTITY_SPEC_(electric_field_strength, force / electric_charge); // vector -QUANTITY_SPEC_(electric_potential, electric_field_strength* length, quantity_character::scalar); +QUANTITY_SPEC_(electric_potential, electric_field_strength* length, quantity_character::real_scalar); QUANTITY_SPEC_(voltage, electric_potential); QUANTITY_SPEC_(electromagnetism_power, power, voltage* electric_current); -QUANTITY_SPEC_(electric_current_phasor, electric_current, quantity_character::complex); -QUANTITY_SPEC_(voltage_phasor, voltage, quantity_character::complex); +QUANTITY_SPEC_(electric_current_phasor, electric_current, quantity_character::complex_scalar); +QUANTITY_SPEC_(voltage_phasor, voltage, quantity_character::complex_scalar); QUANTITY_SPEC_(active_power, power, inverse(period_duration) * (electromagnetism_power * time)); QUANTITY_SPEC_(complex_power, voltage_phasor* electric_current_phasor); // separate kind -QUANTITY_SPEC_(apparent_power, complex_power, quantity_character::scalar); +QUANTITY_SPEC_(apparent_power, complex_power, quantity_character::real_scalar); // clang-format on @@ -1012,12 +1012,6 @@ static_assert(convertible(kind_of, solid_angular_measure_r static_assert(convertible(kind_of, kind_of) == yes); static_assert(convertible(kind_of, kind_of) == yes); - -// quantity character checks -static_assert((displacement / time).character == quantity_character::vector); -static_assert((position_vector / position_vector * time).character == quantity_character::scalar); -static_assert((velocity / acceleration).character == quantity_character::scalar); - // get_common_quantity_spec static_assert(get_common_quantity_spec(length, length) == length); static_assert(get_common_quantity_spec(kind_of, kind_of) == kind_of); diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp index c15322f1..8d9a1e0c 100644 --- a/test/static/quantity_test.cpp +++ b/test/static/quantity_test.cpp @@ -30,7 +30,6 @@ #include #if MP_UNITS_HOSTED #include -#include #include #endif #ifdef MP_UNITS_IMPORT_STD