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

refactor: basic_symbol_text renamed to symbol_text

Browse Source
This commit is contained in:
Mateusz Pusz
2024-03-18 23:12:39 +09:00
parent 7a0baae1ee
commit fb97c2ea5a
17 changed files with 110 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
docs/users_guide/framework_basics/text_output.md
View File

@@ -101,11 +101,11 @@ and units of derived quantities.
!!! tip !!! tip
For older compilers, it might be required to specify a `basic_symbol_text` class explicitly For older compilers, it might be required to specify a `symbol_text` class explicitly
template name to initialize it with two symbols: template name to initialize it with two symbols:
```cpp ```cpp
inline constexpr struct ohm : named_unit<basic_symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm; inline constexpr struct ohm : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
``` ```

6
src/core/include/mp-units/bits/dimension_concepts.h
View File

@@ -29,12 +29,12 @@
namespace mp_units { namespace mp_units {
MP_UNITS_EXPORT template<basic_symbol_text Symbol> MP_UNITS_EXPORT template<symbol_text Symbol>
struct base_dimension; struct base_dimension;
namespace detail { namespace detail {
template<basic_symbol_text Symbol> template<symbol_text Symbol>
void to_base_specialization_of_base_dimension(const volatile base_dimension<Symbol>*); void to_base_specialization_of_base_dimension(const volatile base_dimension<Symbol>*);
template<typename T> template<typename T>
@@ -44,7 +44,7 @@ inline constexpr bool is_derived_from_specialization_of_base_dimension =
template<typename T> template<typename T>
inline constexpr bool is_specialization_of_base_dimension = false; inline constexpr bool is_specialization_of_base_dimension = false;
template<basic_symbol_text Symbol> template<symbol_text Symbol>
inline constexpr bool is_specialization_of_base_dimension<base_dimension<Symbol>> = true; inline constexpr bool is_specialization_of_base_dimension<base_dimension<Symbol>> = true;
/** /**

16
src/core/include/mp-units/bits/magnitude.h
View File

@@ -861,7 +861,7 @@ template<typename T, auto... Ms>
return integer_part((detail::abs(power_of_2) < detail::abs(power_of_5)) ? power_of_2 : power_of_5); return integer_part((detail::abs(power_of_2) < detail::abs(power_of_5)) ? power_of_2 : power_of_5);
} }
inline constexpr basic_symbol_text base_multiplier(u8"× 10", "x 10"); inline constexpr symbol_text base_multiplier(u8"× 10", "x 10");
template<Magnitude auto M> template<Magnitude auto M>
[[nodiscard]] consteval auto magnitude_text() [[nodiscard]] consteval auto magnitude_text()
@@ -880,23 +880,23 @@ template<Magnitude auto M>
if constexpr (num_value == 1 && den_value == 1 && exp10 != 0) { if constexpr (num_value == 1 && den_value == 1 && exp10 != 0) {
return base_multiplier + superscript<exp10>(); return base_multiplier + superscript<exp10>();
} else if constexpr (num_value != 1 || den_value != 1 || exp10 != 0) { } else if constexpr (num_value != 1 || den_value != 1 || exp10 != 0) {
auto txt = basic_symbol_text("[") + regular<num_value>(); auto txt = symbol_text("[") + regular<num_value>();
if constexpr (den_value == 1) { if constexpr (den_value == 1) {
if constexpr (exp10 == 0) { if constexpr (exp10 == 0) {
return txt + basic_symbol_text("]"); return txt + symbol_text("]");
} else { } else {
return txt + basic_symbol_text(" ") + base_multiplier + superscript<exp10>() + basic_symbol_text("]"); return txt + symbol_text(" ") + base_multiplier + superscript<exp10>() + symbol_text("]");
} }
} else { } else {
if constexpr (exp10 == 0) { if constexpr (exp10 == 0) {
return txt + basic_symbol_text("/") + regular<den_value>() + basic_symbol_text("]"); return txt + symbol_text("/") + regular<den_value>() + symbol_text("]");
} else { } else {
return txt + basic_symbol_text("/") + regular<den_value>() + basic_symbol_text(" ") + base_multiplier + return txt + symbol_text("/") + regular<den_value>() + symbol_text(" ") + base_multiplier +
superscript<exp10>() + basic_symbol_text("]"); superscript<exp10>() + symbol_text("]");
} }
} }
} else { } else {
return basic_symbol_text(""); return symbol_text("");
} }
} }

35
src/core/include/mp-units/bits/symbol_text.h
View File

@@ -79,36 +79,35 @@ constexpr fixed_u8string<N> to_u8string(fixed_string<N> txt)
* @tparam M The size of the ASCII-only symbol * @tparam M The size of the ASCII-only symbol
*/ */
MP_UNITS_EXPORT template<std::size_t N, std::size_t M> MP_UNITS_EXPORT template<std::size_t N, std::size_t M>
struct basic_symbol_text { struct symbol_text {
fixed_u8string<N> unicode_; fixed_u8string<N> unicode_;
fixed_string<M> ascii_; fixed_string<M> ascii_;
constexpr explicit(false) basic_symbol_text(char ch) : unicode_(static_cast<char8_t>(ch)), ascii_(ch) constexpr explicit(false) symbol_text(char ch) : unicode_(static_cast<char8_t>(ch)), ascii_(ch)
{ {
gsl_Expects(detail::is_basic_literal_character_set_char(ch)); gsl_Expects(detail::is_basic_literal_character_set_char(ch));
} }
constexpr explicit(false) basic_symbol_text(const char (&txt)[N + 1]) : constexpr explicit(false) symbol_text(const char (&txt)[N + 1]) :
unicode_(detail::to_u8string(basic_fixed_string{txt})), ascii_(txt) unicode_(detail::to_u8string(basic_fixed_string{txt})), ascii_(txt)
{ {
gsl_ExpectsAudit(txt[N] == char{}); gsl_ExpectsAudit(txt[N] == char{});
gsl_Expects(detail::is_basic_literal_character_set(txt)); gsl_Expects(detail::is_basic_literal_character_set(txt));
} }
constexpr explicit(false) basic_symbol_text(const fixed_string<N>& txt) : constexpr explicit(false) symbol_text(const fixed_string<N>& txt) : unicode_(detail::to_u8string(txt)), ascii_(txt)
unicode_(detail::to_u8string(txt)), ascii_(txt)
{ {
gsl_Expects(detail::is_basic_literal_character_set(txt.data_)); gsl_Expects(detail::is_basic_literal_character_set(txt.data_));
} }
constexpr basic_symbol_text(const char8_t (&u)[N + 1], const char (&a)[M + 1]) : unicode_(u), ascii_(a) constexpr symbol_text(const char8_t (&u)[N + 1], const char (&a)[M + 1]) : unicode_(u), ascii_(a)
{ {
gsl_ExpectsAudit(u[N] == char8_t{}); gsl_ExpectsAudit(u[N] == char8_t{});
gsl_ExpectsAudit(a[M] == char{}); gsl_ExpectsAudit(a[M] == char{});
gsl_Expects(detail::is_basic_literal_character_set(a)); gsl_Expects(detail::is_basic_literal_character_set(a));
} }
constexpr basic_symbol_text(const fixed_u8string<N>& u, const fixed_string<M>& a) : unicode_(u), ascii_(a) constexpr symbol_text(const fixed_u8string<N>& u, const fixed_string<M>& a) : unicode_(u), ascii_(a)
{ {
gsl_Expects(detail::is_basic_literal_character_set(a.data_)); gsl_Expects(detail::is_basic_literal_character_set(a.data_));
} }
@@ -123,15 +122,14 @@ struct basic_symbol_text {
} }
template<std::size_t N2, std::size_t M2> template<std::size_t N2, std::size_t M2>
[[nodiscard]] constexpr friend basic_symbol_text<N + N2, M + M2> operator+(const basic_symbol_text& lhs, [[nodiscard]] constexpr friend symbol_text<N + N2, M + M2> operator+(const symbol_text& lhs,
const basic_symbol_text<N2, M2>& rhs) const symbol_text<N2, M2>& rhs)
{ {
return basic_symbol_text<N + N2, M + M2>(lhs.unicode() + rhs.unicode(), lhs.ascii() + rhs.ascii()); return symbol_text<N + N2, M + M2>(lhs.unicode() + rhs.unicode(), lhs.ascii() + rhs.ascii());
} }
template<std::size_t N2, std::size_t M2> template<std::size_t N2, std::size_t M2>
[[nodiscard]] friend constexpr auto operator<=>(const basic_symbol_text& lhs, [[nodiscard]] friend constexpr auto operator<=>(const symbol_text& lhs, const symbol_text<N2, M2>& rhs) noexcept
const basic_symbol_text<N2, M2>& rhs) noexcept
{ {
MP_UNITS_DIAGNOSTIC_PUSH MP_UNITS_DIAGNOSTIC_PUSH
MP_UNITS_DIAGNOSTIC_IGNORE_ZERO_AS_NULLPOINTER_CONSTANT MP_UNITS_DIAGNOSTIC_IGNORE_ZERO_AS_NULLPOINTER_CONSTANT
@@ -141,25 +139,24 @@ struct basic_symbol_text {
} }
template<std::size_t N2, std::size_t M2> template<std::size_t N2, std::size_t M2>
[[nodiscard]] friend constexpr bool operator==(const basic_symbol_text& lhs, [[nodiscard]] friend constexpr bool operator==(const symbol_text& lhs, const symbol_text<N2, M2>& rhs) noexcept
const basic_symbol_text<N2, M2>& rhs) noexcept
{ {
return lhs.unicode() == rhs.unicode() && lhs.ascii() == rhs.ascii(); return lhs.unicode() == rhs.unicode() && lhs.ascii() == rhs.ascii();
} }
}; };
basic_symbol_text(char) -> basic_symbol_text<1, 1>; symbol_text(char) -> symbol_text<1, 1>;
template<std::size_t N> template<std::size_t N>
basic_symbol_text(const char (&)[N]) -> basic_symbol_text<N - 1, N - 1>; symbol_text(const char (&)[N]) -> symbol_text<N - 1, N - 1>;
template<std::size_t N> template<std::size_t N>
basic_symbol_text(const fixed_string<N>&) -> basic_symbol_text<N, N>; symbol_text(const fixed_string<N>&) -> symbol_text<N, N>;
template<std::size_t N, std::size_t M> template<std::size_t N, std::size_t M>
basic_symbol_text(const char8_t (&)[N], const char (&)[M]) -> basic_symbol_text<N - 1, M - 1>; symbol_text(const char8_t (&)[N], const char (&)[M]) -> symbol_text<N - 1, M - 1>;
template<std::size_t N, std::size_t M> template<std::size_t N, std::size_t M>
basic_symbol_text(const fixed_u8string<N>&, const fixed_string<M>&) -> basic_symbol_text<N, M>; symbol_text(const fixed_u8string<N>&, const fixed_string<M>&) -> symbol_text<N, M>;
} // namespace mp_units } // namespace mp_units

20
src/core/include/mp-units/bits/text_tools.h
View File

@@ -56,9 +56,9 @@ inline constexpr basic_fixed_string superscript_number<8> = u8"\u2078";
template<> template<>
inline constexpr basic_fixed_string superscript_number<9> = u8"\u2079"; inline constexpr basic_fixed_string superscript_number<9> = u8"\u2079";
inline constexpr basic_symbol_text superscript_minus(u8"\u207b", "-"); inline constexpr symbol_text superscript_minus(u8"\u207b", "-");
inline constexpr basic_symbol_text superscript_prefix(u8"", "^"); inline constexpr symbol_text superscript_prefix(u8"", "^");
template<std::intmax_t Value> template<std::intmax_t Value>
[[nodiscard]] consteval auto superscript_helper() [[nodiscard]] consteval auto superscript_helper()
@@ -66,7 +66,7 @@ template<std::intmax_t Value>
if constexpr (Value < 0) if constexpr (Value < 0)
return superscript_minus + superscript_helper<-Value>(); return superscript_minus + superscript_helper<-Value>();
else if constexpr (Value < 10) else if constexpr (Value < 10)
return basic_symbol_text(superscript_number<Value>, basic_fixed_string(static_cast<char>('0' + Value))); return symbol_text(superscript_number<Value>, basic_fixed_string(static_cast<char>('0' + Value)));
else else
return superscript_helper<Value / 10>() + superscript_helper<Value % 10>(); return superscript_helper<Value / 10>() + superscript_helper<Value % 10>();
} }
@@ -81,9 +81,9 @@ template<std::intmax_t Value>
[[nodiscard]] consteval auto regular() [[nodiscard]] consteval auto regular()
{ {
if constexpr (Value < 0) if constexpr (Value < 0)
return basic_symbol_text("-") + superscript_helper<-Value>(); return symbol_text("-") + superscript_helper<-Value>();
else if constexpr (Value < 10) else if constexpr (Value < 10)
return basic_symbol_text(static_cast<char>('0' + Value)); return symbol_text(static_cast<char>('0' + Value));
else else
return regular<Value / 10>() + regular<Value % 10>(); return regular<Value / 10>() + regular<Value % 10>();
} }
@@ -99,7 +99,7 @@ MP_UNITS_EXPORT enum class text_encoding : std::int8_t {
namespace detail { namespace detail {
template<typename CharT, std::size_t N, std::size_t M, std::output_iterator<CharT> Out> template<typename CharT, std::size_t N, std::size_t M, std::output_iterator<CharT> Out>
constexpr Out copy(const basic_symbol_text<N, M>& txt, text_encoding encoding, Out out) constexpr Out copy(const symbol_text<N, M>& txt, text_encoding encoding, Out out)
{ {
if (encoding == text_encoding::unicode) { if (encoding == text_encoding::unicode) {
if constexpr (is_same_v<CharT, char8_t>) if constexpr (is_same_v<CharT, char8_t>)
@@ -118,7 +118,7 @@ constexpr Out copy(const basic_symbol_text<N, M>& txt, text_encoding encoding, O
} }
template<typename CharT, std::size_t N, std::size_t M, std::output_iterator<CharT> Out> template<typename CharT, std::size_t N, std::size_t M, std::output_iterator<CharT> Out>
constexpr Out copy_symbol(const basic_symbol_text<N, M>& txt, text_encoding encoding, bool negative_power, Out out) constexpr Out copy_symbol(const symbol_text<N, M>& txt, text_encoding encoding, bool negative_power, Out out)
{ {
out = copy<CharT>(txt, encoding, out); out = copy<CharT>(txt, encoding, out);
if (negative_power) { if (negative_power) {
@@ -135,12 +135,12 @@ constexpr Out copy_symbol_exponent(text_encoding encoding, bool negative_power,
if constexpr (r.den != 1) { if constexpr (r.den != 1) {
// add root part // add root part
if (negative_power) { if (negative_power) {
constexpr auto txt = basic_symbol_text("^-(") + regular<r.num>() + basic_symbol_text("/") + regular<r.den>() + constexpr auto txt =
basic_symbol_text(")"); symbol_text("^-(") + regular<r.num>() + symbol_text("/") + regular<r.den>() + symbol_text(")");
return copy<CharT>(txt, encoding, out); return copy<CharT>(txt, encoding, out);
} else { } else {
constexpr auto txt = constexpr auto txt =
basic_symbol_text("^(") + regular<r.num>() + basic_symbol_text("/") + regular<r.den>() + basic_symbol_text(")"); symbol_text("^(") + regular<r.num>() + symbol_text("/") + regular<r.den>() + symbol_text(")");
return copy<CharT>(txt, encoding, out); return copy<CharT>(txt, encoding, out);
} }
} else if constexpr (r.num != 1) { } else if constexpr (r.num != 1) {

14
src/core/include/mp-units/bits/unit_concepts.h
View File

@@ -49,12 +49,12 @@ concept Unit = detail::is_unit<T>::value;
template<Magnitude auto M, Unit U> template<Magnitude auto M, Unit U>
struct scaled_unit; struct scaled_unit;
MP_UNITS_EXPORT template<basic_symbol_text Symbol, auto...> MP_UNITS_EXPORT template<symbol_text Symbol, auto...>
struct named_unit; struct named_unit;
namespace detail { namespace detail {
template<basic_symbol_text Symbol, auto... Args> template<symbol_text Symbol, auto... Args>
void to_base_specialization_of_named_unit(const volatile named_unit<Symbol, Args...>*); void to_base_specialization_of_named_unit(const volatile named_unit<Symbol, Args...>*);
template<typename T> template<typename T>
@@ -64,7 +64,7 @@ inline constexpr bool is_derived_from_specialization_of_named_unit =
template<typename T> template<typename T>
inline constexpr bool is_specialization_of_named_unit = false; inline constexpr bool is_specialization_of_named_unit = false;
template<basic_symbol_text Symbol, auto... Args> template<symbol_text Symbol, auto... Args>
inline constexpr bool is_specialization_of_named_unit<named_unit<Symbol, Args...>> = true; inline constexpr bool is_specialization_of_named_unit<named_unit<Symbol, Args...>> = true;
/** /**
@@ -114,7 +114,7 @@ concept DerivedUnitExpr = Unit<T> || detail::is_power_of_unit<T> || detail::is_p
template<detail::DerivedUnitExpr... Expr> template<detail::DerivedUnitExpr... Expr>
struct derived_unit; struct derived_unit;
MP_UNITS_EXPORT template<basic_symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U> MP_UNITS_EXPORT template<symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U>
requires(!Symbol.empty()) requires(!Symbol.empty())
struct prefixed_unit; struct prefixed_unit;
@@ -123,7 +123,7 @@ namespace detail {
template<auto M, typename U> template<auto M, typename U>
void is_unit_impl(const scaled_unit<M, U>*); void is_unit_impl(const scaled_unit<M, U>*);
template<basic_symbol_text Symbol, auto... Args> template<symbol_text Symbol, auto... Args>
void is_unit_impl(const named_unit<Symbol, Args...>*); void is_unit_impl(const named_unit<Symbol, Args...>*);
template<typename... Expr> template<typename... Expr>
@@ -132,13 +132,13 @@ void is_unit_impl(const derived_unit<Expr...>*);
template<typename T> template<typename T>
inline constexpr bool is_specialization_of_unit = false; inline constexpr bool is_specialization_of_unit = false;
template<basic_symbol_text Symbol, auto... Args> template<symbol_text Symbol, auto... Args>
inline constexpr bool is_specialization_of_unit<named_unit<Symbol, Args...>> = true; inline constexpr bool is_specialization_of_unit<named_unit<Symbol, Args...>> = true;
template<typename T> template<typename T>
inline constexpr bool is_specialization_of_prefixed_unit = false; inline constexpr bool is_specialization_of_prefixed_unit = false;
template<basic_symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U> template<symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U>
inline constexpr bool is_specialization_of_prefixed_unit<prefixed_unit<Symbol, M, U>> = true; inline constexpr bool is_specialization_of_prefixed_unit<prefixed_unit<Symbol, M, U>> = true;
template<typename T> template<typename T>

2
src/core/include/mp-units/dimension.h
View File

@@ -68,7 +68,7 @@ namespace mp_units {
* *
* @tparam Symbol an unique identifier of the base dimension used to provide dimensional analysis support * @tparam Symbol an unique identifier of the base dimension used to provide dimensional analysis support
*/ */
MP_UNITS_EXPORT template<basic_symbol_text Symbol> MP_UNITS_EXPORT template<symbol_text Symbol>
struct base_dimension { struct base_dimension {
static constexpr auto symbol = Symbol; ///< Unique base dimension identifier static constexpr auto symbol = Symbol; ///< Unique base dimension identifier
}; };

34
src/core/include/mp-units/unit.h
View File

@@ -111,7 +111,7 @@ inline constexpr bool is_specialization_of_scaled_unit<scaled_unit<M, U>> = true
* *
* @tparam Symbol a short text representation of the unit * @tparam Symbol a short text representation of the unit
*/ */
MP_UNITS_EXPORT template<basic_symbol_text Symbol, auto...> MP_UNITS_EXPORT template<symbol_text Symbol, auto...>
struct named_unit; struct named_unit;
/** /**
@@ -130,14 +130,14 @@ struct named_unit;
* @tparam Symbol a short text representation of the unit * @tparam Symbol a short text representation of the unit
* @tparam QuantitySpec a specification of a base quantity to be measured with this unit * @tparam QuantitySpec a specification of a base quantity to be measured with this unit
*/ */
template<basic_symbol_text Symbol, detail::QuantityKindSpec auto QS> template<symbol_text Symbol, detail::QuantityKindSpec auto QS>
requires(!Symbol.empty()) && detail::BaseDimension<std::remove_const_t<decltype(QS.dimension)>> requires(!Symbol.empty()) && detail::BaseDimension<std::remove_const_t<decltype(QS.dimension)>>
struct named_unit<Symbol, QS> { struct named_unit<Symbol, QS> {
static constexpr auto symbol = Symbol; ///< Unique base unit identifier static constexpr auto symbol = Symbol; ///< Unique base unit identifier
static constexpr auto quantity_spec = QS; static constexpr auto quantity_spec = QS;
}; };
template<basic_symbol_text Symbol, detail::QuantityKindSpec auto QS, PointOrigin auto PO> template<symbol_text Symbol, detail::QuantityKindSpec auto QS, PointOrigin auto PO>
requires(!Symbol.empty()) && detail::BaseDimension<std::remove_const_t<decltype(QS.dimension)>> requires(!Symbol.empty()) && detail::BaseDimension<std::remove_const_t<decltype(QS.dimension)>>
struct named_unit<Symbol, QS, PO> { struct named_unit<Symbol, QS, PO> {
static constexpr auto symbol = Symbol; ///< Unique base unit identifier static constexpr auto symbol = Symbol; ///< Unique base unit identifier
@@ -155,7 +155,7 @@ struct named_unit<Symbol, QS, PO> {
* *
* @tparam Symbol a short text representation of the unit * @tparam Symbol a short text representation of the unit
*/ */
template<basic_symbol_text Symbol> template<symbol_text Symbol>
requires(!Symbol.empty()) requires(!Symbol.empty())
struct named_unit<Symbol> { struct named_unit<Symbol> {
static constexpr auto symbol = Symbol; ///< Unique base unit identifier static constexpr auto symbol = Symbol; ///< Unique base unit identifier
@@ -169,13 +169,13 @@ struct named_unit<Symbol> {
* @tparam Symbol a short text representation of the unit * @tparam Symbol a short text representation of the unit
* @tparam Unit a unit for which we provide a special name * @tparam Unit a unit for which we provide a special name
*/ */
template<basic_symbol_text Symbol, Unit auto U> template<symbol_text Symbol, Unit auto U>
requires(!Symbol.empty()) requires(!Symbol.empty())
struct named_unit<Symbol, U> : std::remove_const_t<decltype(U)> { struct named_unit<Symbol, U> : std::remove_const_t<decltype(U)> {
static constexpr auto symbol = Symbol; ///< Unique unit identifier static constexpr auto symbol = Symbol; ///< Unique unit identifier
}; };
template<basic_symbol_text Symbol, Unit auto U, PointOrigin auto PO> template<symbol_text Symbol, Unit auto U, PointOrigin auto PO>
requires(!Symbol.empty()) requires(!Symbol.empty())
struct named_unit<Symbol, U, PO> : std::remove_const_t<decltype(U)> { struct named_unit<Symbol, U, PO> : std::remove_const_t<decltype(U)> {
static constexpr auto symbol = Symbol; ///< Unique unit identifier static constexpr auto symbol = Symbol; ///< Unique unit identifier
@@ -191,14 +191,14 @@ struct named_unit<Symbol, U, PO> : std::remove_const_t<decltype(U)> {
* @tparam Unit a unit for which we provide a special name * @tparam Unit a unit for which we provide a special name
* @tparam QuantitySpec a specification of a quantity to be measured with this unit * @tparam QuantitySpec a specification of a quantity to be measured with this unit
*/ */
template<basic_symbol_text Symbol, AssociatedUnit auto U, detail::QuantityKindSpec auto QS> template<symbol_text Symbol, AssociatedUnit auto U, detail::QuantityKindSpec auto QS>
requires(!Symbol.empty()) && (QS.dimension == detail::get_associated_quantity(U).dimension) requires(!Symbol.empty()) && (QS.dimension == detail::get_associated_quantity(U).dimension)
struct named_unit<Symbol, U, QS> : std::remove_const_t<decltype(U)> { struct named_unit<Symbol, U, QS> : std::remove_const_t<decltype(U)> {
static constexpr auto symbol = Symbol; ///< Unique unit identifier static constexpr auto symbol = Symbol; ///< Unique unit identifier
static constexpr auto quantity_spec = QS; static constexpr auto quantity_spec = QS;
}; };
template<basic_symbol_text Symbol, AssociatedUnit auto U, detail::QuantityKindSpec auto QS, PointOrigin auto PO> template<symbol_text Symbol, AssociatedUnit auto U, detail::QuantityKindSpec auto QS, PointOrigin auto PO>
requires(!Symbol.empty()) && (QS.dimension == detail::get_associated_quantity(U).dimension) requires(!Symbol.empty()) && (QS.dimension == detail::get_associated_quantity(U).dimension)
struct named_unit<Symbol, U, QS, PO> : std::remove_const_t<decltype(U)> { struct named_unit<Symbol, U, QS, PO> : std::remove_const_t<decltype(U)> {
static constexpr auto symbol = Symbol; ///< Unique unit identifier static constexpr auto symbol = Symbol; ///< Unique unit identifier
@@ -228,7 +228,7 @@ struct named_unit<Symbol, U, QS, PO> : std::remove_const_t<decltype(U)> {
* @tparam M scaling factor of the prefix * @tparam M scaling factor of the prefix
* @tparam U a named unit to be prefixed * @tparam U a named unit to be prefixed
*/ */
MP_UNITS_EXPORT template<basic_symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U> MP_UNITS_EXPORT template<symbol_text Symbol, Magnitude auto M, PrefixableUnit auto U>
requires(!Symbol.empty()) requires(!Symbol.empty())
struct prefixed_unit : std::remove_const_t<decltype(M * U)> { struct prefixed_unit : std::remove_const_t<decltype(M * U)> {
static constexpr auto symbol = Symbol + U.symbol; static constexpr auto symbol = Symbol + U.symbol;
@@ -330,13 +330,13 @@ canonical_unit(M, U) -> canonical_unit<M, U>;
#endif #endif
template<Unit T, basic_symbol_text Symbol, detail::QuantityKindSpec auto Q, auto... Args> template<Unit T, symbol_text Symbol, detail::QuantityKindSpec auto Q, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Q, Args...>&); [[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Q, Args...>&);
template<Unit T, basic_symbol_text Symbol, auto... Args> template<Unit T, symbol_text Symbol, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Args...>&); [[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Args...>&);
template<Unit T, basic_symbol_text Symbol, Unit auto U, auto... Args> template<Unit T, symbol_text Symbol, Unit auto U, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T, const named_unit<Symbol, U, Args...>&); [[nodiscard]] consteval auto get_canonical_unit_impl(T, const named_unit<Symbol, U, Args...>&);
template<typename T, typename F, int Num, int... Den> template<typename T, typename F, int Num, int... Den>
@@ -352,19 +352,19 @@ template<Unit T, auto M, typename U>
return canonical_unit{M * base.mag, base.reference_unit}; return canonical_unit{M * base.mag, base.reference_unit};
} }
template<Unit T, basic_symbol_text Symbol, detail::QuantityKindSpec auto Q, auto... Args> template<Unit T, symbol_text Symbol, detail::QuantityKindSpec auto Q, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Q, Args...>&) [[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Q, Args...>&)
{ {
return canonical_unit{mag<1>, t}; return canonical_unit{mag<1>, t};
} }
template<Unit T, basic_symbol_text Symbol, auto... Args> template<Unit T, symbol_text Symbol, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Args...>&) [[nodiscard]] consteval auto get_canonical_unit_impl(T t, const named_unit<Symbol, Args...>&)
{ {
return canonical_unit{mag<1>, t}; return canonical_unit{mag<1>, t};
} }
template<Unit T, basic_symbol_text Symbol, Unit auto U, auto... Args> template<Unit T, symbol_text Symbol, Unit auto U, auto... Args>
[[nodiscard]] consteval auto get_canonical_unit_impl(T, const named_unit<Symbol, U, Args...>&) [[nodiscard]] consteval auto get_canonical_unit_impl(T, const named_unit<Symbol, U, Args...>&)
{ {
return get_canonical_unit_impl(U, U); return get_canonical_unit_impl(U, U);
@@ -491,7 +491,7 @@ namespace detail {
[[nodiscard]] consteval bool have_same_canonical_reference_unit_impl(...) { return false; } [[nodiscard]] consteval bool have_same_canonical_reference_unit_impl(...) { return false; }
template<basic_symbol_text Symbol, auto... D> template<symbol_text Symbol, auto... D>
[[nodiscard]] consteval bool have_same_canonical_reference_unit_impl(const named_unit<Symbol, D...>&, [[nodiscard]] consteval bool have_same_canonical_reference_unit_impl(const named_unit<Symbol, D...>&,
const named_unit<Symbol, D...>&) const named_unit<Symbol, D...>&)
{ {
@@ -618,7 +618,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Unit U>
// common dimensionless units // common dimensionless units
// clang-format off // clang-format off
inline constexpr struct percent : named_unit<"%", mag<ratio{1, 100}> * one> {} percent; inline constexpr struct percent : named_unit<"%", mag<ratio{1, 100}> * one> {} percent;
inline constexpr struct per_mille : named_unit<basic_symbol_text{u8"‰", "%o"}, mag<ratio(1, 1000)> * one> {} per_mille; inline constexpr struct per_mille : named_unit<symbol_text{u8"‰", "%o"}, mag<ratio(1, 1000)> * one> {} per_mille;
inline constexpr struct parts_per_million : named_unit<"ppm", mag<ratio(1, 1'000'000)> * one> {} parts_per_million; inline constexpr struct parts_per_million : named_unit<"ppm", mag<ratio(1, 1'000'000)> * one> {} parts_per_million;
inline constexpr auto ppm = parts_per_million; inline constexpr auto ppm = parts_per_million;
// clang-format on // clang-format on

4
src/systems/include/mp-units/systems/angular/units.h
View File

@@ -40,8 +40,8 @@ QUANTITY_SPEC(solid_angle, pow<2>(angle));
inline constexpr struct radian : named_unit<"rad", kind_of<angle>> {} radian; inline constexpr struct radian : named_unit<"rad", kind_of<angle>> {} radian;
inline constexpr struct revolution : named_unit<"rev", mag<2> * mag_pi * radian> {} revolution; inline constexpr struct revolution : named_unit<"rev", mag<2> * mag_pi * radian> {} revolution;
inline constexpr struct degree : named_unit<basic_symbol_text{u8"°", "deg"}, mag<ratio{1, 360}> * revolution> {} degree; inline constexpr struct degree : named_unit<symbol_text{u8"°", "deg"}, mag<ratio{1, 360}> * revolution> {} degree;
inline constexpr struct gradian : named_unit<basic_symbol_text{u8"ᵍ", "grad"}, mag<ratio{1, 400}> * revolution> {} gradian; inline constexpr struct gradian : named_unit<symbol_text{u8"ᵍ", "grad"}, mag<ratio{1, 400}> * revolution> {} gradian;
inline constexpr struct steradian : named_unit<"sr", square(radian)> {} steradian; inline constexpr struct steradian : named_unit<"sr", square(radian)> {} steradian;
// clang-format on // clang-format on

8
src/systems/include/mp-units/systems/iau/iau.h
View File

@@ -43,7 +43,7 @@ inline constexpr struct Julian_year : named_unit<"a", mag<ratio{365'25, 100}> *
// mass // mass
// https://en.wikipedia.org/wiki/Solar_mass // https://en.wikipedia.org/wiki/Solar_mass
// TODO What is the official mass of sun (every source in the Internet provides a different value) // TODO What is the official mass of sun (every source in the Internet provides a different value)
inline constexpr struct solar_mass : named_unit<basic_symbol_text{u8"M_☉", "M_SUN"}, mag<ratio{198'847, 100'000}> * mag_power<10, 30> * si::kilogram> {} solar_mass; inline constexpr struct solar_mass : named_unit<symbol_text{u8"M_☉", "M_SUN"}, mag<ratio{198'847, 100'000}> * mag_power<10, 30> * si::kilogram> {} solar_mass;
inline constexpr struct Jupiter_mass : named_unit<"M_JUP", mag<ratio{1'898, 1'000}> * mag_power<10, 27> * si::kilogram> {} Jupiter_mass; inline constexpr struct Jupiter_mass : named_unit<"M_JUP", mag<ratio{1'898, 1'000}> * mag_power<10, 27> * si::kilogram> {} Jupiter_mass;
inline constexpr struct Earth_mass : named_unit<"M_EARTH", mag<ratio{59'742, 10'000}> * mag_power<10, 24> * si::kilogram> {} Earth_mass; inline constexpr struct Earth_mass : named_unit<"M_EARTH", mag<ratio{59'742, 10'000}> * mag_power<10, 24> * si::kilogram> {} Earth_mass;
@@ -60,7 +60,7 @@ inline constexpr struct light_year : named_unit<"ly", mag<9'460'730'472'580'800>
inline constexpr struct parsec : named_unit<"pc", astronomical_unit / (mag<ratio{1, 60 * 60}> * si::degree)> {} parsec; inline constexpr struct parsec : named_unit<"pc", astronomical_unit / (mag<ratio{1, 60 * 60}> * si::degree)> {} parsec;
// https://en.wikipedia.org/wiki/Angstrom // https://en.wikipedia.org/wiki/Angstrom
inline constexpr struct angstrom : named_unit<basic_symbol_text{u8"Å", "A"}, mag_power<10, -10> * si::metre> {} angstrom; inline constexpr struct angstrom : named_unit<symbol_text{u8"Å", "A"}, mag_power<10, -10> * si::metre> {} angstrom;
// selected constants // selected constants
// https://en.wikipedia.org/wiki/Astronomical_constant // https://en.wikipedia.org/wiki/Astronomical_constant
@@ -68,13 +68,13 @@ inline constexpr struct gaussian_gravitational_constant :
named_unit<"k", mag<ratio{1'720'209'895, 100'000'000'000}> * pow<3, 2>(astronomical_unit) / pow<1,2>(solar_mass) / day> {} gaussian_gravitational_constant; named_unit<"k", mag<ratio{1'720'209'895, 100'000'000'000}> * pow<3, 2>(astronomical_unit) / pow<1,2>(solar_mass) / day> {} gaussian_gravitational_constant;
inline constexpr struct speed_of_light : inline constexpr struct speed_of_light :
named_unit<basic_symbol_text{u8"c₀", "c_0"}, si::si2019::speed_of_light_in_vacuum> {} speed_of_light; named_unit<symbol_text{u8"c₀", "c_0"}, si::si2019::speed_of_light_in_vacuum> {} speed_of_light;
inline constexpr struct constant_of_gravitation : inline constexpr struct constant_of_gravitation :
named_unit<"G", mag<ratio{667'430, 100'000}> * mag_power<10, -11> * cubic(si::metre) / si::kilogram / square(si::second)> {} constant_of_gravitation; named_unit<"G", mag<ratio{667'430, 100'000}> * mag_power<10, -11> * cubic(si::metre) / si::kilogram / square(si::second)> {} constant_of_gravitation;
inline constexpr struct hubble_constant : inline constexpr struct hubble_constant :
named_unit<basic_symbol_text{u8"H₀", "H_0"}, mag<ratio{701, 10}> * si::kilo<si::metre> / si::second / si::mega<parsec>> {} hubble_constant; named_unit<symbol_text{u8"H₀", "H_0"}, mag<ratio{701, 10}> * si::kilo<si::metre> / si::second / si::mega<parsec>> {} hubble_constant;
// clang-format on // clang-format on
namespace unit_symbols { namespace unit_symbols {

2
src/systems/include/mp-units/systems/isq/base_quantities.h
View File

@@ -39,7 +39,7 @@ inline constexpr struct dim_length : base_dimension<"L"> {} dim_length;
inline constexpr struct dim_mass : base_dimension<"M"> {} dim_mass; inline constexpr struct dim_mass : base_dimension<"M"> {} dim_mass;
inline constexpr struct dim_time : base_dimension<"T"> {} dim_time; inline constexpr struct dim_time : base_dimension<"T"> {} dim_time;
inline constexpr struct dim_electric_current : base_dimension<"I"> {} dim_electric_current; inline constexpr struct dim_electric_current : base_dimension<"I"> {} dim_electric_current;
inline constexpr struct dim_thermodynamic_temperature : base_dimension<basic_symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature; inline constexpr struct dim_thermodynamic_temperature : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
inline constexpr struct dim_amount_of_substance : base_dimension<"N"> {} dim_amount_of_substance; inline constexpr struct dim_amount_of_substance : base_dimension<"N"> {} dim_amount_of_substance;
inline constexpr struct dim_luminous_intensity : base_dimension<"J"> {} dim_luminous_intensity; inline constexpr struct dim_luminous_intensity : base_dimension<"J"> {} dim_luminous_intensity;
// clang-format on // clang-format on

6
src/systems/include/mp-units/systems/si/constants.h
View File

@@ -36,7 +36,7 @@ namespace si2019 {
// clang-format off // clang-format off
inline constexpr struct hyperfine_structure_transition_frequency_of_cs : inline constexpr struct hyperfine_structure_transition_frequency_of_cs :
named_unit<basic_symbol_text{u8"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs; named_unit<symbol_text{u8"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs;
inline constexpr struct speed_of_light_in_vacuum : inline constexpr struct speed_of_light_in_vacuum :
named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum; named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
inline constexpr struct planck_constant : inline constexpr struct planck_constant :
@@ -55,9 +55,9 @@ inline constexpr struct luminous_efficacy :
// clang-format off // clang-format off
inline constexpr struct standard_gravity : inline constexpr struct standard_gravity :
named_unit<basic_symbol_text{u8"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity; named_unit<symbol_text{u8"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity;
inline constexpr struct magnetic_constant : inline constexpr struct magnetic_constant :
named_unit<basic_symbol_text{u8"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant; named_unit<symbol_text{u8"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant;
// clang-format on // clang-format on
} // namespace mp_units::si } // namespace mp_units::si

2
src/systems/include/mp-units/systems/si/prefixes.h
View File

@@ -39,7 +39,7 @@ template<PrefixableUnit U> struct atto_ : prefixed_unit<"a", mag_power<10, -18>
template<PrefixableUnit U> struct femto_ : prefixed_unit<"f", mag_power<10, -15>, U{}> {}; template<PrefixableUnit U> struct femto_ : prefixed_unit<"f", mag_power<10, -15>, U{}> {};
template<PrefixableUnit U> struct pico_ : prefixed_unit<"p", mag_power<10, -12>, U{}> {}; template<PrefixableUnit U> struct pico_ : prefixed_unit<"p", mag_power<10, -12>, U{}> {};
template<PrefixableUnit U> struct nano_ : prefixed_unit<"n", mag_power<10, -9>, U{}> {}; template<PrefixableUnit U> struct nano_ : prefixed_unit<"n", mag_power<10, -9>, U{}> {};
template<PrefixableUnit U> struct micro_ : prefixed_unit<basic_symbol_text{u8"µ", "u"}, mag_power<10, -6>, U{}> {}; template<PrefixableUnit U> struct micro_ : prefixed_unit<symbol_text{u8"µ", "u"}, mag_power<10, -6>, U{}> {};
template<PrefixableUnit U> struct milli_ : prefixed_unit<"m", mag_power<10, -3>, U{}> {}; template<PrefixableUnit U> struct milli_ : prefixed_unit<"m", mag_power<10, -3>, U{}> {};
template<PrefixableUnit U> struct centi_ : prefixed_unit<"c", mag_power<10, -2>, U{}> {}; template<PrefixableUnit U> struct centi_ : prefixed_unit<"c", mag_power<10, -2>, U{}> {};
template<PrefixableUnit U> struct deci_ : prefixed_unit<"d", mag_power<10, -1>, U{}> {}; template<PrefixableUnit U> struct deci_ : prefixed_unit<"d", mag_power<10, -1>, U{}> {};

10
src/systems/include/mp-units/systems/si/units.h
View File

@@ -75,7 +75,7 @@ inline constexpr struct watt : named_unit<"W", joule / second> {} watt;
inline constexpr struct coulomb : named_unit<"C", ampere * second> {} coulomb; inline constexpr struct coulomb : named_unit<"C", ampere * second> {} coulomb;
inline constexpr struct volt : named_unit<"V", watt / ampere> {} volt; inline constexpr struct volt : named_unit<"V", watt / ampere> {} volt;
inline constexpr struct farad : named_unit<"F", coulomb / volt> {} farad; inline constexpr struct farad : named_unit<"F", coulomb / volt> {} farad;
inline constexpr struct ohm : named_unit<basic_symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm; inline constexpr struct ohm : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
inline constexpr struct siemens : named_unit<"S", one / ohm> {} siemens; inline constexpr struct siemens : named_unit<"S", one / ohm> {} siemens;
inline constexpr struct weber : named_unit<"Wb", volt * second> {} weber; inline constexpr struct weber : named_unit<"Wb", volt * second> {} weber;
inline constexpr struct tesla : named_unit<"T", weber / square(metre)> {} tesla; inline constexpr struct tesla : named_unit<"T", weber / square(metre)> {} tesla;
@@ -83,7 +83,7 @@ inline constexpr struct henry : named_unit<"H", weber / ampere> {} henry;
inline constexpr struct ice_point : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point; inline constexpr struct ice_point : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
inline constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius; inline constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius;
inline constexpr struct degree_Celsius : named_unit<basic_symbol_text{u8"°C", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius; inline constexpr struct degree_Celsius : named_unit<symbol_text{u8"°C", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
inline constexpr struct lumen : named_unit<"lm", candela * steradian> {} lumen; inline constexpr struct lumen : named_unit<"lm", candela * steradian> {} lumen;
inline constexpr struct lux : named_unit<"lx", lumen / square(metre)> {} lux; inline constexpr struct lux : named_unit<"lx", lumen / square(metre)> {} lux;
@@ -103,9 +103,9 @@ inline constexpr struct minute : named_unit<"min", mag<60> * si::second> {} minu
inline constexpr struct hour : named_unit<"h", mag<60> * minute> {} hour; inline constexpr struct hour : named_unit<"h", mag<60> * minute> {} hour;
inline constexpr struct day : named_unit<"d", mag<24> * hour> {} day; inline constexpr struct day : named_unit<"d", mag<24> * hour> {} day;
inline constexpr struct astronomical_unit : named_unit<"au", mag<149'597'870'700> * si::metre> {} astronomical_unit; inline constexpr struct astronomical_unit : named_unit<"au", mag<149'597'870'700> * si::metre> {} astronomical_unit;
inline constexpr struct degree : named_unit<basic_symbol_text{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree; inline constexpr struct degree : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
inline constexpr struct arcminute : named_unit<basic_symbol_text{u8"′", "'"}, mag<ratio{1, 60}> * degree> {} arcminute; inline constexpr struct arcminute : named_unit<symbol_text{u8"′", "'"}, mag<ratio{1, 60}> * degree> {} arcminute;
inline constexpr struct arcsecond : named_unit<basic_symbol_text{u8"″", "''"}, mag<ratio{1, 60}> * arcminute> {} arcsecond; inline constexpr struct arcsecond : named_unit<symbol_text{u8"″", "''"}, mag<ratio{1, 60}> * arcminute> {} arcsecond;
inline constexpr struct are : named_unit<"a", square(si::deca<si::metre>)> {} are; inline constexpr struct are : named_unit<"a", square(si::deca<si::metre>)> {} are;
#if MP_UNITS_COMP_MSVC #if MP_UNITS_COMP_MSVC
inline constexpr struct hectare : si::hecto_<are> {} hectare; inline constexpr struct hectare : si::hecto_<are> {} hectare;

2
src/systems/include/mp-units/systems/usc/usc.h
View File

@@ -116,7 +116,7 @@ inline constexpr struct inch_of_mercury : named_unit<"inHg", mag<ratio(3'386'389
// https://en.wikipedia.org/wiki/United_States_customary_units#Temperature // https://en.wikipedia.org/wiki/United_States_customary_units#Temperature
inline constexpr struct zeroth_degree_Fahrenheit : relative_point_origin<si::zeroth_degree_Celsius - 32 * (mag<ratio{5, 9}> * si::degree_Celsius)> {} zeroth_degree_Fahrenheit; inline constexpr struct zeroth_degree_Fahrenheit : relative_point_origin<si::zeroth_degree_Celsius - 32 * (mag<ratio{5, 9}> * si::degree_Celsius)> {} zeroth_degree_Fahrenheit;
inline constexpr struct degree_Fahrenheit : named_unit<basic_symbol_text{u8"°F", "`F"}, mag<ratio{5, 9}> * si::degree_Celsius, zeroth_degree_Fahrenheit> {} degree_Fahrenheit; inline constexpr struct degree_Fahrenheit : named_unit<symbol_text{u8"°F", "`F"}, mag<ratio{5, 9}> * si::degree_Celsius, zeroth_degree_Fahrenheit> {} degree_Fahrenheit;
// clang-format on // clang-format on

46
test/static/symbol_text_test.cpp
View File

@@ -26,10 +26,10 @@ using namespace mp_units;
namespace { namespace {
constexpr basic_symbol_text sym1('b'); constexpr symbol_text sym1('b');
static_assert(sym1 == 'b'); static_assert(sym1 == 'b');
static_assert(sym1 != 'a'); static_assert(sym1 != 'a');
static_assert(sym1 != basic_symbol_text("ab")); static_assert(sym1 != symbol_text("ab"));
static_assert(sym1 < 'c'); static_assert(sym1 < 'c');
static_assert(sym1 > 'a'); static_assert(sym1 > 'a');
static_assert(sym1 <= 'b'); static_assert(sym1 <= 'b');
@@ -39,45 +39,45 @@ static_assert(sym1 >= 'a');
static_assert(sym1.unicode() == u8"b"); static_assert(sym1.unicode() == u8"b");
static_assert(sym1.ascii() == "b"); static_assert(sym1.ascii() == "b");
constexpr basic_symbol_text sym3("ab"); constexpr symbol_text sym3("ab");
static_assert(sym3.unicode() == u8"ab"); static_assert(sym3.unicode() == u8"ab");
static_assert(sym3.ascii() == "ab"); static_assert(sym3.ascii() == "ab");
constexpr basic_fixed_string txt1("bc"); constexpr basic_fixed_string txt1("bc");
constexpr basic_symbol_text sym4(txt1); constexpr symbol_text sym4(txt1);
static_assert(sym4.unicode() == u8"bc"); static_assert(sym4.unicode() == u8"bc");
static_assert(sym4.ascii() == "bc"); static_assert(sym4.ascii() == "bc");
constexpr basic_symbol_text sym5(u8"bc", "de"); constexpr symbol_text sym5(u8"bc", "de");
static_assert(sym5.unicode() == u8"bc"); static_assert(sym5.unicode() == u8"bc");
static_assert(sym5.ascii() == "de"); static_assert(sym5.ascii() == "de");
constexpr basic_fixed_string txt2("de"); constexpr basic_fixed_string txt2("de");
constexpr basic_symbol_text sym6(sym4.unicode(), txt2); constexpr symbol_text sym6(sym4.unicode(), txt2);
static_assert(sym6.unicode() == u8"bc"); static_assert(sym6.unicode() == u8"bc");
static_assert(sym6.ascii() == "de"); static_assert(sym6.ascii() == "de");
static_assert(sym6 == basic_symbol_text(u8"bc", "de")); static_assert(sym6 == symbol_text(u8"bc", "de"));
static_assert(sym6 != basic_symbol_text(u8"fg", "hi")); static_assert(sym6 != symbol_text(u8"fg", "hi"));
static_assert(sym6 != basic_symbol_text(u8"bcd", "ef")); static_assert(sym6 != symbol_text(u8"bcd", "ef"));
static_assert(sym6 < basic_symbol_text("c")); static_assert(sym6 < symbol_text("c"));
static_assert(sym6 > basic_symbol_text("a")); static_assert(sym6 > symbol_text("a"));
static_assert(sym6 <= basic_symbol_text("c")); static_assert(sym6 <= symbol_text("c"));
static_assert(sym6 <= basic_symbol_text("bcd")); static_assert(sym6 <= symbol_text("bcd"));
static_assert(sym6 >= basic_symbol_text("a")); static_assert(sym6 >= symbol_text("a"));
static_assert(sym6 >= basic_symbol_text("bc")); static_assert(sym6 >= symbol_text("bc"));
static_assert(basic_symbol_text("a") + sym4 == basic_symbol_text("abc")); static_assert(symbol_text("a") + sym4 == symbol_text("abc"));
static_assert(sym4 + basic_symbol_text("f") == basic_symbol_text("bcf")); static_assert(sym4 + symbol_text("f") == symbol_text("bcf"));
static_assert(basic_symbol_text(u8"a", "f") + sym6 == basic_symbol_text(u8"abc", "fde")); static_assert(symbol_text(u8"a", "f") + sym6 == symbol_text(u8"abc", "fde"));
static_assert(sym6 + basic_symbol_text(u8"a", "f") == basic_symbol_text(u8"bca", "def")); static_assert(sym6 + symbol_text(u8"a", "f") == symbol_text(u8"bca", "def"));
static_assert(basic_symbol_text('a') + sym6 == basic_symbol_text(u8"abc", "ade")); static_assert(symbol_text('a') + sym6 == symbol_text(u8"abc", "ade"));
static_assert(sym6 + basic_symbol_text('f') == basic_symbol_text(u8"bcf", "def")); static_assert(sym6 + symbol_text('f') == symbol_text(u8"bcf", "def"));
static_assert(basic_symbol_text("a") + sym6 == basic_symbol_text(u8"abc", "ade")); static_assert(symbol_text("a") + sym6 == symbol_text(u8"abc", "ade"));
static_assert(sym6 + basic_symbol_text("f") == basic_symbol_text(u8"bcf", "def")); static_assert(sym6 + symbol_text("f") == symbol_text(u8"bcf", "def"));
} // namespace } // namespace

12
test/static/unit_test.cpp
View File

@@ -40,7 +40,7 @@ using percent_ = struct percent;
inline constexpr struct dim_length_ : base_dimension<"L"> {} dim_length; inline constexpr struct dim_length_ : base_dimension<"L"> {} dim_length;
inline constexpr struct dim_mass_ : base_dimension<"M"> {} dim_mass; inline constexpr struct dim_mass_ : base_dimension<"M"> {} dim_mass;
inline constexpr struct dim_time_ : base_dimension<"T"> {} dim_time; inline constexpr struct dim_time_ : base_dimension<"T"> {} dim_time;
inline constexpr struct dim_thermodynamic_temperature_ : base_dimension<basic_symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature; inline constexpr struct dim_thermodynamic_temperature_ : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
// quantities specification // quantities specification
QUANTITY_SPEC_(length, dim_length); QUANTITY_SPEC_(length, dim_length);
@@ -67,11 +67,11 @@ inline constexpr struct newton_ : named_unit<"N", kilogram * metre / square(seco
inline constexpr struct pascal_ : named_unit<"Pa", newton / square(metre)> {} pascal; inline constexpr struct pascal_ : named_unit<"Pa", newton / square(metre)> {} pascal;
inline constexpr struct joule_ : named_unit<"J", newton * metre> {} joule; inline constexpr struct joule_ : named_unit<"J", newton * metre> {} joule;
inline constexpr struct watt_ : named_unit<"W", joule / second> {} watt; inline constexpr struct watt_ : named_unit<"W", joule / second> {} watt;
inline constexpr struct degree_Celsius_ : named_unit<basic_symbol_text{u8"°C", "`C"}, kelvin> {} degree_Celsius; inline constexpr struct degree_Celsius_ : named_unit<symbol_text{u8"°C", "`C"}, kelvin> {} degree_Celsius;
inline constexpr struct minute_ : named_unit<"min", mag<60> * second> {} minute; inline constexpr struct minute_ : named_unit<"min", mag<60> * second> {} minute;
inline constexpr struct hour_ : named_unit<"h", mag<60> * minute> {} hour; inline constexpr struct hour_ : named_unit<"h", mag<60> * minute> {} hour;
inline constexpr struct degree_ : named_unit<basic_symbol_text{u8"°", "deg"}, mag_pi / mag<180> * radian> {} degree; inline constexpr struct degree_ : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * radian> {} degree;
inline constexpr struct yard_ : named_unit<"yd", mag<ratio{9'144, 10'000}> * metre> {} yard; inline constexpr struct yard_ : named_unit<"yd", mag<ratio{9'144, 10'000}> * metre> {} yard;
inline constexpr struct mile_ : named_unit<"mi", mag<1760> * yard> {} mile; inline constexpr struct mile_ : named_unit<"mi", mag<1760> * yard> {} mile;
@@ -80,7 +80,7 @@ inline constexpr struct kilometre_ : decltype(si::kilo<metre>) {} kilometre;
inline constexpr struct kilojoule_ : decltype(si::kilo<joule>) {} kilojoule; inline constexpr struct kilojoule_ : decltype(si::kilo<joule>) {} kilojoule;
// physical constant units // physical constant units
inline constexpr struct standard_gravity_ : named_unit<basic_symbol_text{u8"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity; inline constexpr struct standard_gravity_ : named_unit<symbol_text{u8"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity;
inline constexpr struct speed_of_light_in_vacuum_ : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum; inline constexpr struct speed_of_light_in_vacuum_ : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
// clang-format on // clang-format on
@@ -190,7 +190,7 @@ static_assert(convertible(standard_gravity, standard_gravity));
static_assert(convertible(standard_gravity, metre / square(second))); static_assert(convertible(standard_gravity, metre / square(second)));
static_assert(standard_gravity == standard_gravity); static_assert(standard_gravity == standard_gravity);
static_assert(standard_gravity != metre / square(second)); // magnitude is different static_assert(standard_gravity != metre / square(second)); // magnitude is different
static_assert(standard_gravity.symbol == basic_symbol_text{u8"g₀", "g_0"}); static_assert(standard_gravity.symbol == symbol_text{u8"g₀", "g_0"});
// prefixed_unit // prefixed_unit
static_assert(is_of_type<kilometre, kilometre_>); static_assert(is_of_type<kilometre, kilometre_>);
@@ -225,7 +225,7 @@ static_assert(si::atto<metre>.symbol == "am");
static_assert(si::femto<metre>.symbol == "fm"); static_assert(si::femto<metre>.symbol == "fm");
static_assert(si::pico<metre>.symbol == "pm"); static_assert(si::pico<metre>.symbol == "pm");
static_assert(si::nano<metre>.symbol == "nm"); static_assert(si::nano<metre>.symbol == "nm");
static_assert(si::micro<metre>.symbol == basic_symbol_text{u8"µm", "um"}); static_assert(si::micro<metre>.symbol == symbol_text{u8"µm", "um"});
static_assert(si::milli<metre>.symbol == "mm"); static_assert(si::milli<metre>.symbol == "mm");
static_assert(si::centi<metre>.symbol == "cm"); static_assert(si::centi<metre>.symbol == "cm");
static_assert(si::deci<metre>.symbol == "dm"); static_assert(si::deci<metre>.symbol == "dm");