mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-03 20:34:26 +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
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:
```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 {
MP_UNITS_EXPORT template<basic_symbol_text Symbol>
MP_UNITS_EXPORT template<symbol_text Symbol>
struct base_dimension;
namespace detail {
template<basic_symbol_text Symbol>
template<symbol_text Symbol>
void to_base_specialization_of_base_dimension(const volatile base_dimension<Symbol>*);
template<typename T>
@@ -44,7 +44,7 @@ inline constexpr bool is_derived_from_specialization_of_base_dimension =
template<typename T>
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;
/**

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);
}
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>
[[nodiscard]] consteval auto magnitude_text()
@@ -880,23 +880,23 @@ template<Magnitude auto M>
if constexpr (num_value == 1 && den_value == 1 && exp10 != 0) {
return base_multiplier + superscript<exp10>();
} 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 (exp10 == 0) {
return txt + basic_symbol_text("]");
return txt + symbol_text("]");
} else {
return txt + basic_symbol_text(" ") + base_multiplier + superscript<exp10>() + basic_symbol_text("]");
return txt + symbol_text(" ") + base_multiplier + superscript<exp10>() + symbol_text("]");
}
} else {
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 {
return txt + basic_symbol_text("/") + regular<den_value>() + basic_symbol_text(" ") + base_multiplier +
superscript<exp10>() + basic_symbol_text("]");
return txt + symbol_text("/") + regular<den_value>() + symbol_text(" ") + base_multiplier +
superscript<exp10>() + symbol_text("]");
}
}
} 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
*/
MP_UNITS_EXPORT template<std::size_t N, std::size_t M>
struct basic_symbol_text {
struct symbol_text {
fixed_u8string<N> unicode_;
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));
}
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)
{
gsl_ExpectsAudit(txt[N] == char{});
gsl_Expects(detail::is_basic_literal_character_set(txt));
}
constexpr explicit(false) basic_symbol_text(const fixed_string<N>& txt) :
unicode_(detail::to_u8string(txt)), ascii_(txt)
constexpr explicit(false) symbol_text(const fixed_string<N>& txt) : unicode_(detail::to_u8string(txt)), ascii_(txt)
{
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(a[M] == char{});
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_));
}
@@ -123,15 +122,14 @@ struct basic_symbol_text {
}
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,
const basic_symbol_text<N2, M2>& rhs)
[[nodiscard]] constexpr friend symbol_text<N + N2, M + M2> operator+(const symbol_text& lhs,
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>
[[nodiscard]] friend constexpr auto operator<=>(const basic_symbol_text& lhs,
const basic_symbol_text<N2, M2>& rhs) noexcept
[[nodiscard]] friend constexpr auto operator<=>(const symbol_text& lhs, const symbol_text<N2, M2>& rhs) noexcept
{
MP_UNITS_DIAGNOSTIC_PUSH
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>
[[nodiscard]] friend constexpr bool operator==(const basic_symbol_text& lhs,
const basic_symbol_text<N2, M2>& rhs) noexcept
[[nodiscard]] friend constexpr bool operator==(const symbol_text& lhs, const symbol_text<N2, M2>& rhs) noexcept
{
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>
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>
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>
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>
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

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<>
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>
[[nodiscard]] consteval auto superscript_helper()
@@ -66,7 +66,7 @@ template<std::intmax_t Value>
if constexpr (Value < 0)
return superscript_minus + superscript_helper<-Value>();
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
return superscript_helper<Value / 10>() + superscript_helper<Value % 10>();
}
@@ -81,9 +81,9 @@ template<std::intmax_t Value>
[[nodiscard]] consteval auto regular()
{
if constexpr (Value < 0)
return basic_symbol_text("-") + superscript_helper<-Value>();
return symbol_text("-") + superscript_helper<-Value>();
else if constexpr (Value < 10)
return basic_symbol_text(static_cast<char>('0' + Value));
return symbol_text(static_cast<char>('0' + Value));
else
return regular<Value / 10>() + regular<Value % 10>();
}
@@ -99,7 +99,7 @@ MP_UNITS_EXPORT enum class text_encoding : std::int8_t {
namespace detail {
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 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>
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);
if (negative_power) {
@@ -135,12 +135,12 @@ constexpr Out copy_symbol_exponent(text_encoding encoding, bool negative_power,
if constexpr (r.den != 1) {
// add root part
if (negative_power) {
constexpr auto txt = basic_symbol_text("^-(") + regular<r.num>() + basic_symbol_text("/") + regular<r.den>() +
basic_symbol_text(")");
constexpr auto txt =
symbol_text("^-(") + regular<r.num>() + symbol_text("/") + regular<r.den>() + symbol_text(")");
return copy<CharT>(txt, encoding, out);
} else {
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);
}
} 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>
struct scaled_unit;
MP_UNITS_EXPORT template<basic_symbol_text Symbol, auto...>
MP_UNITS_EXPORT template<symbol_text Symbol, auto...>
struct named_unit;
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...>*);
template<typename T>
@@ -64,7 +64,7 @@ inline constexpr bool is_derived_from_specialization_of_named_unit =
template<typename T>
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;
/**
@@ -114,7 +114,7 @@ concept DerivedUnitExpr = Unit<T> || detail::is_power_of_unit<T> || detail::is_p
template<detail::DerivedUnitExpr... Expr>
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())
struct prefixed_unit;
@@ -123,7 +123,7 @@ namespace detail {
template<auto M, typename 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...>*);
template<typename... Expr>
@@ -132,13 +132,13 @@ void is_unit_impl(const derived_unit<Expr...>*);
template<typename T>
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;
template<typename T>
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;
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
*/
MP_UNITS_EXPORT template<basic_symbol_text Symbol>
MP_UNITS_EXPORT template<symbol_text Symbol>
struct base_dimension {
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
*/
MP_UNITS_EXPORT template<basic_symbol_text Symbol, auto...>
MP_UNITS_EXPORT template<symbol_text Symbol, auto...>
struct named_unit;
/**
@@ -130,14 +130,14 @@ struct named_unit;
* @tparam Symbol a short text representation of the 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)>>
struct named_unit<Symbol, QS> {
static constexpr auto symbol = Symbol; ///< Unique base unit identifier
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)>>
struct named_unit<Symbol, QS, PO> {
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
*/
template<basic_symbol_text Symbol>
template<symbol_text Symbol>
requires(!Symbol.empty())
struct named_unit<Symbol> {
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 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())
struct named_unit<Symbol, U> : std::remove_const_t<decltype(U)> {
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())
struct named_unit<Symbol, U, PO> : std::remove_const_t<decltype(U)> {
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 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)
struct named_unit<Symbol, U, QS> : std::remove_const_t<decltype(U)> {
static constexpr auto symbol = Symbol; ///< Unique unit identifier
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)
struct named_unit<Symbol, U, QS, PO> : std::remove_const_t<decltype(U)> {
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 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())
struct prefixed_unit : std::remove_const_t<decltype(M * U)> {
static constexpr auto symbol = Symbol + U.symbol;
@@ -330,13 +330,13 @@ canonical_unit(M, U) -> canonical_unit<M, U>;
#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...>&);
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...>&);
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...>&);
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};
}
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...>&)
{
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...>&)
{
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...>&)
{
return get_canonical_unit_impl(U, U);
@@ -491,7 +491,7 @@ namespace detail {
[[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...>&,
const named_unit<Symbol, D...>&)
{
@@ -618,7 +618,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Unit U>
// common dimensionless units
// clang-format off
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 auto ppm = parts_per_million;
// 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 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 gradian : named_unit<basic_symbol_text{u8"ᵍ", "grad"}, mag<ratio{1, 400}> * revolution> {} gradian;
inline constexpr struct degree : named_unit<symbol_text{u8"°", "deg"}, mag<ratio{1, 360}> * revolution> {} degree;
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;
// 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
// https://en.wikipedia.org/wiki/Solar_mass
// 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 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;
// 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
// 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;
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 :
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 :
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
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_time : base_dimension<"T"> {} dim_time;
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_luminous_intensity : base_dimension<"J"> {} dim_luminous_intensity;
// clang-format on

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

@@ -36,7 +36,7 @@ namespace si2019 {
// clang-format off
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 :
named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
inline constexpr struct planck_constant :
@@ -55,9 +55,9 @@ inline constexpr struct luminous_efficacy :
// clang-format off
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 :
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
} // 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 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 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 centi_ : prefixed_unit<"c", mag_power<10, -2>, 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 volt : named_unit<"V", watt / ampere> {} volt;
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 weber : named_unit<"Wb", volt * second> {} weber;
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 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 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 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 degree : named_unit<basic_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 arcsecond : named_unit<basic_symbol_text{u8"″", "''"}, mag<ratio{1, 60}> * arcminute> {} arcsecond;
inline constexpr struct degree : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
inline constexpr struct arcminute : named_unit<symbol_text{u8"′", "'"}, mag<ratio{1, 60}> * degree> {} arcminute;
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;
#if MP_UNITS_COMP_MSVC
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
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

46
test/static/symbol_text_test.cpp
View File

@@ -26,10 +26,10 @@ using namespace mp_units;
namespace {
constexpr basic_symbol_text sym1('b');
constexpr symbol_text sym1('b');
static_assert(sym1 == 'b');
static_assert(sym1 != 'a');
static_assert(sym1 != basic_symbol_text("ab"));
static_assert(sym1 != symbol_text("ab"));
static_assert(sym1 < 'c');
static_assert(sym1 > 'a');
static_assert(sym1 <= 'b');
@@ -39,45 +39,45 @@ static_assert(sym1 >= 'a');
static_assert(sym1.unicode() == u8"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.ascii() == "ab");
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.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.ascii() == "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.ascii() == "de");
static_assert(sym6 == basic_symbol_text(u8"bc", "de"));
static_assert(sym6 != basic_symbol_text(u8"fg", "hi"));
static_assert(sym6 != basic_symbol_text(u8"bcd", "ef"));
static_assert(sym6 == symbol_text(u8"bc", "de"));
static_assert(sym6 != symbol_text(u8"fg", "hi"));
static_assert(sym6 != symbol_text(u8"bcd", "ef"));
static_assert(sym6 < basic_symbol_text("c"));
static_assert(sym6 > basic_symbol_text("a"));
static_assert(sym6 <= basic_symbol_text("c"));
static_assert(sym6 <= basic_symbol_text("bcd"));
static_assert(sym6 >= basic_symbol_text("a"));
static_assert(sym6 >= basic_symbol_text("bc"));
static_assert(sym6 < symbol_text("c"));
static_assert(sym6 > symbol_text("a"));
static_assert(sym6 <= symbol_text("c"));
static_assert(sym6 <= symbol_text("bcd"));
static_assert(sym6 >= symbol_text("a"));
static_assert(sym6 >= symbol_text("bc"));
static_assert(basic_symbol_text("a") + sym4 == basic_symbol_text("abc"));
static_assert(sym4 + basic_symbol_text("f") == basic_symbol_text("bcf"));
static_assert(symbol_text("a") + sym4 == symbol_text("abc"));
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(sym6 + basic_symbol_text(u8"a", "f") == basic_symbol_text(u8"bca", "def"));
static_assert(symbol_text(u8"a", "f") + sym6 == symbol_text(u8"abc", "fde"));
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(sym6 + basic_symbol_text('f') == basic_symbol_text(u8"bcf", "def"));
static_assert(symbol_text('a') + sym6 == symbol_text(u8"abc", "ade"));
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(sym6 + basic_symbol_text("f") == basic_symbol_text(u8"bcf", "def"));
static_assert(symbol_text("a") + sym6 == symbol_text(u8"abc", "ade"));
static_assert(sym6 + symbol_text("f") == symbol_text(u8"bcf", "def"));
} // 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_mass_ : base_dimension<"M"> {} dim_mass;
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
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 joule_ : named_unit<"J", newton * metre> {} joule;
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 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 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;
// 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;
// clang-format on
@@ -190,7 +190,7 @@ static_assert(convertible(standard_gravity, standard_gravity));
static_assert(convertible(standard_gravity, metre / square(second)));
static_assert(standard_gravity == standard_gravity);
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
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::pico<metre>.symbol == "pm");
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::centi<metre>.symbol == "cm");
static_assert(si::deci<metre>.symbol == "dm");