feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

Migrate units from ratio to Magnitude

Browse Source 
This commit is huge, but hopefully the cognitive load is not too bad.
The bulk of this commit is just some fairly mechanical updates from
`ratio` to `Magnitude`.  Other things to call out:

- `UnitRatio` goes away.  We don't need this concept, because Magnitude
  can't even _represent_ anything that doesn't satisfy it.

- I commented out some formatting test cases where the precise
  expression changes, but the number is completely equivalent.  We will
  need to decide how we want to handle Magnitude formatting as a
  separate, follow-on task.  But at least Magnitude gives us all the
  tools we'll need to do so!
This commit is contained in:
Chip Hogg
2022-04-09 17:55:44 +00:00
parent 5afe7766e9
commit d19b2803ce
42 changed files with 197 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
example/custom_systems.cpp
View File

@@ -33,7 +33,7 @@ using namespace units;
namespace fps { namespace fps {
struct foot : named_unit<foot, "ft", no_prefix> {}; struct foot : named_unit<foot, "ft", no_prefix> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<3>(), foot> {};
struct dim_length : base_dimension<"L", foot> {}; struct dim_length : base_dimension<"L", foot> {};
@@ -54,8 +54,8 @@ using length = quantity<dim_length, U, Rep>;
namespace fps { namespace fps {
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(3'048, 1'000, -1), metre> {}; struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(3'048, 1'000, -1)>(), metre> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<3>(), foot> {};
struct dim_length : base_dimension<"L", foot> {}; struct dim_length : base_dimension<"L", foot> {};

6
example/literals/custom_systems.cpp
View File

@@ -33,7 +33,7 @@ using namespace units;
namespace fps { namespace fps {
struct foot : named_unit<foot, "ft", no_prefix> {}; struct foot : named_unit<foot, "ft", no_prefix> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<3>(), foot> {};
struct dim_length : base_dimension<"L", foot> {}; struct dim_length : base_dimension<"L", foot> {};
@@ -54,8 +54,8 @@ using length = quantity<dim_length, U, Rep>;
namespace fps { namespace fps {
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(3'048, 1'000, -1), metre> {}; struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(3'048, 1'000, -1)>(), metre> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<3>(), foot> {};
struct dim_length : base_dimension<"L", foot> {}; struct dim_length : base_dimension<"L", foot> {};

10
src/core/include/units/bits/base_units_ratio.h
View File

@@ -45,14 +45,4 @@ constexpr Magnitude auto absolute_magnitude(exponent_list<Es...>)
return (pow<ratio{Es::num, Es::den}>(Es::dimension::base_unit::mag) * ... * magnitude<>{}); return (pow<ratio{Es::num, Es::den}>(Es::dimension::base_unit::mag) * ... * magnitude<>{});
} }
/**
* @brief Calculates the common ratio of all the references of base units in the derived dimension
*/
template<typename... Es>
constexpr ratio base_units_ratio(exponent_list<Es...> es)
{
return as_ratio(absolute_magnitude(es));
}
} // namespace units::detail } // namespace units::detail

17
src/core/include/units/bits/basic_concepts.h
View File

@@ -28,7 +28,7 @@
#include <units/bits/external/fixed_string.h> #include <units/bits/external/fixed_string.h>
#include <units/bits/external/type_traits.h> #include <units/bits/external/type_traits.h>
#include <units/customization_points.h> #include <units/customization_points.h>
#include <units/ratio.h> #include <units/magnitude.h>
// IWYU pragma: end_exports // IWYU pragma: end_exports
#include <cstdint> #include <cstdint>
@@ -67,24 +67,15 @@ void to_prefix_base(const volatile prefix_base<PF, R>*);
template<typename T> template<typename T>
concept Prefix = requires(T* t) { detail::to_prefix_base(t); }; concept Prefix = requires(T* t) { detail::to_prefix_base(t); };
/**
* @brief A concept matching unit's ratio
*
* Satisfied by all ratio values for which `R.num > 0` and `R.den > 0`.
*/
template<ratio R>
concept UnitRatio = (R.num > 0) && (R.den > 0);
// Unit // Unit
template<ratio R, typename U> template<Magnitude auto M, typename U>
requires UnitRatio<R>
struct scaled_unit; struct scaled_unit;
// TODO: Remove when P1985 accepted // TODO: Remove when P1985 accepted
namespace detail { namespace detail {
template<ratio R, typename U> template<Magnitude auto M, typename U>
void to_base_scaled_unit(const volatile scaled_unit<R, U>*); void to_base_scaled_unit(const volatile scaled_unit<M, U>*);
} // namespace detail } // namespace detail

12
src/core/include/units/bits/common_type.h
View File

@@ -55,22 +55,22 @@ struct common_quantity_reference_impl<reference<D, U>, reference<D, U>> {
template<typename D, typename U1, typename U2> template<typename D, typename U1, typename U2>
struct common_quantity_reference_impl<reference<D, U1>, reference<D, U2>> { struct common_quantity_reference_impl<reference<D, U1>, reference<D, U2>> {
using type = reference<D, downcast_unit<D, common_ratio(U1::ratio, U2::ratio)>>; using type = reference<D, downcast_unit<D, common_magnitude(U1::mag, U2::mag)>>;
}; };
template<typename D1, typename U1, typename D2, typename U2> template<typename D1, typename U1, typename D2, typename U2>
requires(same_unit_reference<dimension_unit<D1>, dimension_unit<D2>>::value) requires(same_unit_reference<dimension_unit<D1>, dimension_unit<D2>>::value)
struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> { struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
using type = reference<D1, downcast_unit<D1, common_ratio(U1::ratio, U2::ratio)>>; using type = reference<D1, downcast_unit<D1, common_magnitude(U1::mag, U2::mag)>>;
}; };
template<typename D1, typename U1, typename D2, typename U2> template<typename D1, typename U1, typename D2, typename U2>
struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> { struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
using dimension = conditional<is_specialization_of<D1, unknown_dimension>, D2, D1>; using dimension = conditional<is_specialization_of<D1, unknown_dimension>, D2, D1>;
static constexpr ratio r1 = D1::base_units_ratio * U1::ratio; static constexpr Magnitude auto m1 = D1::base_units_ratio * U1::mag;
static constexpr ratio r2 = D2::base_units_ratio * U2::ratio; static constexpr Magnitude auto m2 = D2::base_units_ratio * U2::mag;
static constexpr ratio cr = common_ratio(r1, r2); static constexpr Magnitude auto cm = common_magnitude(m1, m2);
using unit = downcast_unit<dimension, cr / dimension::base_units_ratio>; using unit = downcast_unit<dimension, cm / dimension::base_units_ratio>;
using type = reference<dimension, unit>; using type = reference<dimension, unit>;
}; };

6
src/core/include/units/bits/derived_unit.h
View File

@@ -43,12 +43,6 @@ constexpr Magnitude auto derived_mag(exponent_list<Es...>)
pow<ratio{Es::num, Es::den}>(Us::mag / dimension_unit<typename Es::dimension>::mag)); pow<ratio{Es::num, Es::den}>(Us::mag / dimension_unit<typename Es::dimension>::mag));
} }
template<Unit... Us, typename... Es>
constexpr ratio derived_ratio(exponent_list<Es...> es)
{
return as_ratio(derived_mag<Us...>(es));
}
template<DerivedDimension D, Unit... Us> template<DerivedDimension D, Unit... Us>
using derived_unit = scaled_unit<derived_mag<Us...>(typename D::recipe()), typename D::coherent_unit::reference>; using derived_unit = scaled_unit<derived_mag<Us...>(typename D::recipe()), typename D::coherent_unit::reference>;

4
src/core/include/units/chrono.h
View File

@@ -34,7 +34,7 @@ namespace units {
template<typename Rep, typename Period> template<typename Rep, typename Period>
struct quantity_like_traits<std::chrono::duration<Rep, Period>> { struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
using dimension = isq::si::dim_time; using dimension = isq::si::dim_time;
using unit = downcast_unit<dimension, ratio(Period::num, Period::den)>; using unit = downcast_unit<dimension, as_magnitude<ratio(Period::num, Period::den)>()>;
using rep = Rep; using rep = Rep;
[[nodiscard]] static constexpr rep number(const std::chrono::duration<Rep, Period>& q) { return q.count(); } [[nodiscard]] static constexpr rep number(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
}; };
@@ -45,7 +45,7 @@ struct clock_origin : point_origin<isq::si::dim_time> {};
template<typename C, typename Rep, typename Period> template<typename C, typename Rep, typename Period>
struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> { struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> {
using origin = clock_origin<C>; using origin = clock_origin<C>;
using unit = downcast_unit<typename origin::dimension, ratio(Period::num, Period::den)>; using unit = downcast_unit<typename origin::dimension, as_magnitude<ratio(Period::num, Period::den)>()>;
using rep = Rep; using rep = Rep;
[[nodiscard]] static constexpr auto relative(const std::chrono::time_point<C, std::chrono::duration<Rep, Period>>& qp) [[nodiscard]] static constexpr auto relative(const std::chrono::time_point<C, std::chrono::duration<Rep, Period>>& qp)
{ {

3
src/core/include/units/derived_dimension.h
View File

@@ -85,7 +85,8 @@ template<typename Child, Unit U, Exponent... Es>
struct derived_dimension : downcast_dispatch<Child, typename detail::make_dimension<Es...>> { struct derived_dimension : downcast_dispatch<Child, typename detail::make_dimension<Es...>> {
using recipe = exponent_list<Es...>; using recipe = exponent_list<Es...>;
using coherent_unit = U; using coherent_unit = U;
static constexpr ratio base_units_ratio = detail::base_units_ratio(typename derived_dimension::exponents()); static constexpr Magnitude auto base_units_ratio =
detail::absolute_magnitude(typename derived_dimension::exponents());
}; };
} // namespace units } // namespace units

2
src/core/include/units/generic/dimensionless.h
View File

@@ -31,7 +31,7 @@
namespace units { namespace units {
struct one : named_unit<one, "", no_prefix> {}; struct one : named_unit<one, "", no_prefix> {};
struct percent : named_scaled_unit<percent, "%", no_prefix, ratio(1, 100), one> {}; struct percent : named_scaled_unit<percent, "%", no_prefix, as_magnitude<ratio(1, 100)>(), one> {};
/** /**
* @brief Dimension one * @brief Dimension one

6
src/core/include/units/math.h
View File

@@ -57,7 +57,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q>
return rep(1); return rep(1);
} else { } else {
using dim = dimension_pow<typename Q::dimension, Num, Den>; using dim = dimension_pow<typename Q::dimension, Num, Den>;
using unit = downcast_unit<dim, pow<Num, Den>(Q::unit::ratio)>; using unit = downcast_unit<dim, pow<ratio{Num, Den}>(Q::unit::mag)>;
using std::pow; using std::pow;
return quantity<dim, unit, rep>( return quantity<dim, unit, rep>(
static_cast<rep>(pow(q.number(), static_cast<double>(Num) / static_cast<double>(Den)))); static_cast<rep>(pow(q.number(), static_cast<double>(Num) / static_cast<double>(Den))));
@@ -77,7 +77,7 @@ template<Quantity Q>
requires requires { sqrt(q.number()); } || requires { std::sqrt(q.number()); } requires requires { sqrt(q.number()); } || requires { std::sqrt(q.number()); }
{ {
using dim = dimension_pow<typename Q::dimension, 1, 2>; using dim = dimension_pow<typename Q::dimension, 1, 2>;
using unit = downcast_unit<dim, sqrt(Q::unit::ratio)>; using unit = downcast_unit<dim, pow<ratio{1, 2}>(Q::unit::mag)>;
using rep = TYPENAME Q::rep; using rep = TYPENAME Q::rep;
using std::sqrt; using std::sqrt;
return quantity<dim, unit, rep>(static_cast<rep>(sqrt(q.number()))); return quantity<dim, unit, rep>(static_cast<rep>(sqrt(q.number())));
@@ -96,7 +96,7 @@ template<Quantity Q>
requires requires { cbrt(q.number()); } || requires { std::cbrt(q.number()); } requires requires { cbrt(q.number()); } || requires { std::cbrt(q.number()); }
{ {
using dim = dimension_pow<typename Q::dimension, 1, 3>; using dim = dimension_pow<typename Q::dimension, 1, 3>;
using unit = downcast_unit<dim, cbrt(Q::unit::ratio)>; using unit = downcast_unit<dim, pow<ratio{1, 3}>(Q::unit::mag)>;
using rep = TYPENAME Q::rep; using rep = TYPENAME Q::rep;
using std::cbrt; using std::cbrt;
return quantity<dim, unit, rep>(static_cast<rep>(cbrt(q.number()))); return quantity<dim, unit, rep>(static_cast<rep>(cbrt(q.number())));

2
src/core/include/units/prefix.h
View File

@@ -25,6 +25,7 @@
#include <units/bits/basic_concepts.h> #include <units/bits/basic_concepts.h>
#include <units/bits/external/downcasting.h> #include <units/bits/external/downcasting.h>
// IWYU pragma: begin_exports // IWYU pragma: begin_exports
#include <units/magnitude.h>
#include <units/ratio.h> #include <units/ratio.h>
#include <units/symbol_text.h> #include <units/symbol_text.h>
// IWYU pragma: end_exports // IWYU pragma: end_exports
@@ -52,6 +53,7 @@ template<PrefixFamily PF, ratio R>
struct prefix_base : downcast_base<prefix_base<PF, R>> { struct prefix_base : downcast_base<prefix_base<PF, R>> {
using prefix_family = PF; using prefix_family = PF;
static constexpr ::units::ratio ratio = R; static constexpr ::units::ratio ratio = R;
static constexpr Magnitude auto mag = as_magnitude<R>();
}; };
} // namespace detail } // namespace detail

2
src/core/include/units/quantity.h
View File

@@ -402,7 +402,7 @@ public:
{ {
gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero()); gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
using dim = dim_invert<D>; using dim = dim_invert<D>;
using ret_unit = downcast_unit<dim, inverse(U::ratio)>; using ret_unit = downcast_unit<dim, pow<-1>(U::mag)>;
using ret = quantity<dim, ret_unit, std::invoke_result_t<std::divides<>, Value, rep>>; using ret = quantity<dim, ret_unit, std::invoke_result_t<std::divides<>, Value, rep>>;
return ret(v / q.number()); return ret(v / q.number());
} }

43
src/core/include/units/quantity_cast.h
View File

@@ -27,6 +27,7 @@
#include <units/bits/pow.h> #include <units/bits/pow.h>
#include <units/concepts.h> #include <units/concepts.h>
#include <units/customization_points.h> #include <units/customization_points.h>
#include <units/magnitude.h>
UNITS_DIAGNOSTIC_PUSH UNITS_DIAGNOSTIC_PUSH
// warning C4244: 'argument': conversion from 'intmax_t' to 'T', possible loss of data with T=int // warning C4244: 'argument': conversion from 'intmax_t' to 'T', possible loss of data with T=int
@@ -49,25 +50,31 @@ class quantity_point_kind;
namespace detail { namespace detail {
template<typename T> template<typename T>
inline constexpr ratio quantity_ratio = std::enable_if_t<!Quantity<T>>{}; inline constexpr Magnitude auto quantity_magnitude = std::enable_if_t<!Quantity<T>, magnitude<>>{};
template<typename D, typename U, typename Rep> template<typename D, typename U, typename Rep>
inline constexpr ratio quantity_ratio<quantity<D, U, Rep>> = [] { inline constexpr Magnitude auto quantity_magnitude<quantity<D, U, Rep>> = [] {
if constexpr (BaseDimension<D>) { if constexpr (BaseDimension<D>) {
return U::ratio; return U::mag;
} else { } else {
return D::base_units_ratio * U::ratio / D::coherent_unit::ratio; return D::base_units_ratio * U::mag / D::coherent_unit::mag;
} }
}(); }();
template<typename T>
inline constexpr ratio quantity_ratio = std::enable_if_t<!Quantity<T>>{};
template<typename D, typename U, typename Rep>
inline constexpr ratio quantity_ratio<quantity<D, U, Rep>> = as_ratio(quantity_magnitude<quantity<D, U, Rep>>);
template<typename QFrom, typename QTo> template<typename QFrom, typename QTo>
inline constexpr ratio cast_ratio = [] { inline constexpr Magnitude auto cast_magnitude = [] {
using FromU = TYPENAME QFrom::unit; using FromU = TYPENAME QFrom::unit;
using ToU = TYPENAME QTo::unit; using ToU = TYPENAME QTo::unit;
if constexpr (same_unit_reference<FromU, ToU>::value) { if constexpr (same_unit_reference<FromU, ToU>::value) {
return FromU::ratio / ToU::ratio; return FromU::mag / ToU::mag;
} else { } else {
return quantity_ratio<QFrom> / quantity_ratio<QTo>; return quantity_magnitude<QFrom> / quantity_magnitude<QTo>;
} }
}(); }();
@@ -112,24 +119,16 @@ template<Quantity To, typename D, typename U, scalable_with_<typename To::rep> R
using traits = detail::cast_traits<Rep, typename To::rep>; using traits = detail::cast_traits<Rep, typename To::rep>;
using ratio_type = TYPENAME traits::ratio_type; using ratio_type = TYPENAME traits::ratio_type;
using rep_type = TYPENAME traits::rep_type; using rep_type = TYPENAME traits::rep_type;
constexpr auto c_ratio = detail::cast_ratio<quantity<D, U, Rep>, To>; constexpr Magnitude auto c_mag = detail::cast_magnitude<quantity<D, U, Rep>, To>;
if constexpr (treat_as_floating_point<rep_type>) { if constexpr (treat_as_floating_point<rep_type>) {
return To( return To(
static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) * static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) * (get_value<ratio_type>(numerator(c_mag)) /
(static_cast<ratio_type>(c_ratio.num) * detail::fpow10<ratio_type>(c_ratio.exp) / get_value<ratio_type>(denominator(c_mag)))));
static_cast<ratio_type>(c_ratio.den))));
} else { } else {
if constexpr (c_ratio.exp > 0) { return To(
return To(static_cast<TYPENAME To::rep>( static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) * get_value<ratio_type>(numerator(c_mag)) /
static_cast<rep_type>(q.number()) * get_value<ratio_type>(denominator(c_mag))));
(static_cast<ratio_type>(c_ratio.num) * static_cast<ratio_type>(detail::ipow10(c_ratio.exp))) /
static_cast<ratio_type>(c_ratio.den)));
} else {
return To(static_cast<TYPENAME To::rep>(
static_cast<rep_type>(q.number()) * static_cast<ratio_type>(c_ratio.num) /
(static_cast<ratio_type>(c_ratio.den) * static_cast<ratio_type>(detail::ipow10(-c_ratio.exp)))));
}
} }
} }
@@ -149,7 +148,7 @@ template<Dimension ToD, typename D, typename U, typename Rep>
requires equivalent<ToD, D> requires equivalent<ToD, D>
[[nodiscard]] constexpr auto quantity_cast(const quantity<D, U, Rep>& q) [[nodiscard]] constexpr auto quantity_cast(const quantity<D, U, Rep>& q)
{ {
return quantity_cast<quantity<ToD, downcast_unit<ToD, U::ratio>, Rep>>(q); return quantity_cast<quantity<ToD, downcast_unit<ToD, U::mag>, Rep>>(q);
} }
/** /**

8
src/core/include/units/reference.h
View File

@@ -37,13 +37,13 @@ namespace detail {
template<typename D, typename D1, typename U1, typename D2, typename U2> template<typename D, typename D1, typename U1, typename D2, typename U2>
using reference_multiply_impl = using reference_multiply_impl =
reference<D, downcast_unit<D, (U1::ratio / dimension_unit<D1>::ratio) * (U2::ratio / dimension_unit<D2>::ratio) * reference<D, downcast_unit<D, (U1::mag / dimension_unit<D1>::mag) * (U2::mag / dimension_unit<D2>::mag) *
dimension_unit<D>::ratio>>; dimension_unit<D>::mag>>;
template<typename D, typename D1, typename U1, typename D2, typename U2> template<typename D, typename D1, typename U1, typename D2, typename U2>
using reference_divide_impl = using reference_divide_impl =
reference<D, downcast_unit<D, (U1::ratio / dimension_unit<D1>::ratio) / (U2::ratio / dimension_unit<D2>::ratio) * reference<D, downcast_unit<D, (U1::mag / dimension_unit<D1>::mag) / (U2::mag / dimension_unit<D2>::mag) *
dimension_unit<D>::ratio>>; dimension_unit<D>::mag>>;
} // namespace detail } // namespace detail

30
src/core/include/units/unit.h
View File

@@ -28,6 +28,7 @@
// IWYU pragma: begin_exports // IWYU pragma: begin_exports
#include <units/bits/derived_unit.h> #include <units/bits/derived_unit.h>
#include <units/bits/external/fixed_string.h> #include <units/bits/external/fixed_string.h>
#include <units/magnitude.h>
#include <units/prefix.h> #include <units/prefix.h>
#include <units/ratio.h> #include <units/ratio.h>
#include <units/symbol_text.h> #include <units/symbol_text.h>
@@ -47,20 +48,18 @@ namespace units {
* (i.e. all length units are expressed in terms of meter, all mass units are expressed in * (i.e. all length units are expressed in terms of meter, all mass units are expressed in
* terms of gram, ...) * terms of gram, ...)
* *
* @tparam R a ratio of a reference unit * @tparam M a Magnitude representing the (relative) size of this unit
* @tparam U a unit to use as a reference for this dimension * @tparam U a unit to use as a reference for this dimension
*/ */
template<ratio R, typename U> template<Magnitude auto M, typename U>
requires UnitRatio<R> struct scaled_unit : downcast_base<scaled_unit<M, U>> {
struct scaled_unit : downcast_base<scaled_unit<R, U>> { static constexpr ::units::ratio ratio = as_ratio(M);
static constexpr ::units::ratio ratio = R; static constexpr Magnitude auto mag = M;
using reference = U; using reference = U;
}; };
template<Dimension D, auto R> template<Dimension D, Magnitude auto M>
// template<Dimension D, ratio R> // TODO: GCC crash!!! using downcast_unit = downcast<scaled_unit<M, typename dimension_unit<D>::reference>>;
requires UnitRatio<R>
using downcast_unit = downcast<scaled_unit<R, typename dimension_unit<D>::reference>>;
template<Unit U1, Unit U2> template<Unit U1, Unit U2>
struct same_unit_reference : is_same<typename U1::reference, typename U2::reference> {}; struct same_unit_reference : is_same<typename U1::reference, typename U2::reference> {};
@@ -74,7 +73,7 @@ struct same_unit_reference : is_same<typename U1::reference, typename U2::refere
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom) * @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
*/ */
template<typename Child> template<typename Child>
struct unit : downcast_dispatch<Child, scaled_unit<ratio(1), Child>> { struct unit : downcast_dispatch<Child, scaled_unit<as_magnitude<1>(), Child>> {
static constexpr bool is_named = false; static constexpr bool is_named = false;
using prefix_family = no_prefix; using prefix_family = no_prefix;
}; };
@@ -92,7 +91,7 @@ struct unit : downcast_dispatch<Child, scaled_unit<ratio(1), Child>> {
* @tparam PF no_prefix or a type of prefix family * @tparam PF no_prefix or a type of prefix family
*/ */
template<typename Child, basic_symbol_text Symbol, PrefixFamily PF> template<typename Child, basic_symbol_text Symbol, PrefixFamily PF>
struct named_unit : downcast_dispatch<Child, scaled_unit<ratio(1), Child>> { struct named_unit : downcast_dispatch<Child, scaled_unit<as_magnitude<1>(), Child>> {
static constexpr bool is_named = true; static constexpr bool is_named = true;
static constexpr auto symbol = Symbol; static constexpr auto symbol = Symbol;
using prefix_family = PF; using prefix_family = PF;
@@ -109,12 +108,11 @@ struct named_unit : downcast_dispatch<Child, scaled_unit<ratio(1), Child>> {
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom) * @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
* @tparam Symbol a short text representation of the unit * @tparam Symbol a short text representation of the unit
* @tparam PF no_prefix or a type of prefix family * @tparam PF no_prefix or a type of prefix family
* @tparam R a scale to apply to U * @tparam M the Magnitude by which to scale U
* @tparam U a reference unit to scale * @tparam U a reference unit to scale
*/ */
template<typename Child, basic_symbol_text Symbol, PrefixFamily PF, ratio R, Unit U> template<typename Child, basic_symbol_text Symbol, PrefixFamily PF, Magnitude auto M, Unit U>
requires UnitRatio<R> struct named_scaled_unit : downcast_dispatch<Child, scaled_unit<M * U::mag, typename U::reference>> {
struct named_scaled_unit : downcast_dispatch<Child, scaled_unit<R * U::ratio, typename U::reference>> {
static constexpr bool is_named = true; static constexpr bool is_named = true;
static constexpr auto symbol = Symbol; static constexpr auto symbol = Symbol;
using prefix_family = PF; using prefix_family = PF;
@@ -133,7 +131,7 @@ struct named_scaled_unit : downcast_dispatch<Child, scaled_unit<R * U::ratio, ty
*/ */
template<typename Child, Prefix P, Unit U> template<typename Child, Prefix P, Unit U>
requires U::is_named && std::same_as<typename P::prefix_family, typename U::prefix_family> requires U::is_named && std::same_as<typename P::prefix_family, typename U::prefix_family>
struct prefixed_unit : downcast_dispatch<Child, scaled_unit<P::ratio * U::ratio, typename U::reference>> { struct prefixed_unit : downcast_dispatch<Child, scaled_unit<P::mag * U::mag, typename U::reference>> {
static constexpr bool is_named = true; static constexpr bool is_named = true;
static constexpr auto symbol = P::symbol + U::symbol; static constexpr auto symbol = P::symbol + U::symbol;
using prefix_family = no_prefix; using prefix_family = no_prefix;

2
src/systems/isq-iec80000/include/units/isq/iec80000/storage_capacity.h
View File

@@ -53,7 +53,7 @@ struct tebibit : prefixed_unit<tebibit, tebi, binary_prefix_bit> {};
struct pebibit : prefixed_unit<pebibit, pebi, binary_prefix_bit> {}; struct pebibit : prefixed_unit<pebibit, pebi, binary_prefix_bit> {};
struct exbibit : prefixed_unit<exbibit, exbi, binary_prefix_bit> {}; struct exbibit : prefixed_unit<exbibit, exbi, binary_prefix_bit> {};
struct byte : named_scaled_unit<byte, "B", si::prefix, ratio(8), bit> {}; struct byte : named_scaled_unit<byte, "B", si::prefix, as_magnitude<8>(), bit> {};
struct kilobyte : prefixed_unit<kilobyte, si::kilo, byte> {}; struct kilobyte : prefixed_unit<kilobyte, si::kilo, byte> {};
struct megabyte : prefixed_unit<megabyte, si::mega, byte> {}; struct megabyte : prefixed_unit<megabyte, si::mega, byte> {};
struct gigabyte : prefixed_unit<gigabyte, si::giga, byte> {}; struct gigabyte : prefixed_unit<gigabyte, si::giga, byte> {};

3
src/systems/si-fps/include/units/isq/si/fps/force.h
View File

@@ -40,7 +40,8 @@ namespace units::isq::si::fps {
struct poundal : named_unit<poundal, "pdl", no_prefix> {}; struct poundal : named_unit<poundal, "pdl", no_prefix> {};
// https://en.wikipedia.org/wiki/Pound_(force) // https://en.wikipedia.org/wiki/Pound_(force)
struct pound_force : named_scaled_unit<pound_force, "lbf", si::prefix, ratio(32'174'049, 1'000'000), poundal> {}; struct pound_force :
named_scaled_unit<pound_force, "lbf", si::prefix, as_magnitude<ratio(32'174'049, 1'000'000)>(), poundal> {};
struct kilopound_force : prefixed_unit<kilopound_force, si::kilo, pound_force> {}; struct kilopound_force : prefixed_unit<kilopound_force, si::kilo, pound_force> {};

14
src/systems/si-fps/include/units/isq/si/fps/length.h
View File

@@ -35,24 +35,24 @@
namespace units::isq::si::fps { namespace units::isq::si::fps {
// https://en.wikipedia.org/wiki/Foot_(unit) // https://en.wikipedia.org/wiki/Foot_(unit)
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(3'048, 1'000, -1), si::metre> {}; struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(3'048, 1'000, -1)>(), si::metre> {};
struct inch : named_scaled_unit<inch, "in", no_prefix, ratio(1, 12), foot> {}; struct inch : named_scaled_unit<inch, "in", no_prefix, as_magnitude<ratio(1, 12)>(), foot> {};
// thousandth of an inch // thousandth of an inch
struct thousandth : named_scaled_unit<thousandth, "thou", no_prefix, ratio(1, 1'000), inch> {}; struct thousandth : named_scaled_unit<thousandth, "thou", no_prefix, as_magnitude<ratio(1, 1'000)>(), inch> {};
struct thou : alias_unit<thousandth, "thou", no_prefix> {}; struct thou : alias_unit<thousandth, "thou", no_prefix> {};
struct mil : alias_unit<thousandth, "mil", no_prefix> {}; struct mil : alias_unit<thousandth, "mil", no_prefix> {};
struct yard : named_scaled_unit<yard, "yd", si::prefix, ratio(3, 1), foot> {}; struct yard : named_scaled_unit<yard, "yd", si::prefix, as_magnitude<3>(), foot> {};
struct fathom : named_scaled_unit<fathom, "ftm", no_prefix, ratio(6, 1), foot> {}; struct fathom : named_scaled_unit<fathom, "ftm", no_prefix, as_magnitude<6>(), foot> {};
struct kiloyard : prefixed_unit<kiloyard, si::kilo, yard> {}; struct kiloyard : prefixed_unit<kiloyard, si::kilo, yard> {};
struct mile : named_scaled_unit<mile, "mile", no_prefix, ratio(5'280), foot> {}; struct mile : named_scaled_unit<mile, "mile", no_prefix, as_magnitude<5'280>(), foot> {};
struct nautical_mile : named_scaled_unit<nautical_mile, "mi(naut)", no_prefix, ratio(2'000), yard> {}; struct nautical_mile : named_scaled_unit<nautical_mile, "mi(naut)", no_prefix, as_magnitude<2'000>(), yard> {};
struct dim_length : isq::dim_length<foot> {}; struct dim_length : isq::dim_length<foot> {};

19
src/systems/si-fps/include/units/isq/si/fps/mass.h
View File

@@ -35,28 +35,29 @@
namespace units::isq::si::fps { namespace units::isq::si::fps {
// https://en.wikipedia.org/wiki/Pound_(mass) // https://en.wikipedia.org/wiki/Pound_(mass)
struct pound : named_scaled_unit<pound, "lb", no_prefix, ratio(45'359'237, 100'000'000), si::kilogram> {}; struct pound :
named_scaled_unit<pound, "lb", no_prefix, as_magnitude<ratio(45'359'237, 100'000'000)>(), si::kilogram> {};
struct dim_mass : isq::dim_mass<pound> {}; struct dim_mass : isq::dim_mass<pound> {};
template<UnitOf<dim_mass> U, Representation Rep = double> template<UnitOf<dim_mass> U, Representation Rep = double>
using mass = quantity<dim_mass, U, Rep>; using mass = quantity<dim_mass, U, Rep>;
struct grain : named_scaled_unit<grain, "gr", no_prefix, ratio(1, 7000), pound> {}; struct grain : named_scaled_unit<grain, "gr", no_prefix, as_magnitude<ratio(1, 7000)>(), pound> {};
struct dram : named_scaled_unit<dram, "dr", no_prefix, ratio(1, 256), pound> {}; struct dram : named_scaled_unit<dram, "dr", no_prefix, as_magnitude<ratio(1, 256)>(), pound> {};
struct ounce : named_scaled_unit<ounce, "oz", no_prefix, ratio(1, 16), pound> {}; struct ounce : named_scaled_unit<ounce, "oz", no_prefix, as_magnitude<ratio(1, 16)>(), pound> {};
struct stone : named_scaled_unit<stone, "st", no_prefix, ratio(14, 1), pound> {}; struct stone : named_scaled_unit<stone, "st", no_prefix, as_magnitude<14>(), pound> {};
struct quarter : named_scaled_unit<quarter, "qr", no_prefix, ratio(28, 1), pound> {}; struct quarter : named_scaled_unit<quarter, "qr", no_prefix, as_magnitude<28>(), pound> {};
struct hundredweight : named_scaled_unit<hundredweight, "cwt", no_prefix, ratio(112, 1), pound> {}; struct hundredweight : named_scaled_unit<hundredweight, "cwt", no_prefix, as_magnitude<112>(), pound> {};
struct short_ton : named_scaled_unit<short_ton, "ton (short)", no_prefix, ratio(2'000, 1), pound> {}; struct short_ton : named_scaled_unit<short_ton, "ton (short)", no_prefix, as_magnitude<2'000>(), pound> {};
struct long_ton : named_scaled_unit<long_ton, "ton (long)", no_prefix, ratio(2'240, 1), pound> {}; struct long_ton : named_scaled_unit<long_ton, "ton (long)", no_prefix, as_magnitude<2'240>(), pound> {};
#ifndef UNITS_NO_LITERALS #ifndef UNITS_NO_LITERALS

3
src/systems/si-fps/include/units/isq/si/fps/power.h
View File

@@ -41,7 +41,8 @@ struct dim_power : isq::dim_power<dim_power, foot_poundal_per_second, dim_length
struct foot_pound_force_per_second : derived_unit<foot_pound_force_per_second, dim_power, foot, pound_force, second> {}; struct foot_pound_force_per_second : derived_unit<foot_pound_force_per_second, dim_power, foot, pound_force, second> {};
struct horse_power : named_scaled_unit<horse_power, "hp", no_prefix, ratio(550), foot_pound_force_per_second> {}; struct horse_power :
named_scaled_unit<horse_power, "hp", no_prefix, as_magnitude<550>(), foot_pound_force_per_second> {};
template<UnitOf<dim_power> U, Representation Rep = double> template<UnitOf<dim_power> U, Representation Rep = double>
using power = quantity<dim_power, U, Rep>; using power = quantity<dim_power, U, Rep>;

5
src/systems/si-fps/include/units/isq/si/fps/pressure.h
View File

@@ -44,11 +44,12 @@ template<UnitOf<dim_pressure> U, Representation Rep = double>
using pressure = quantity<dim_pressure, U, Rep>; using pressure = quantity<dim_pressure, U, Rep>;
struct pound_force_per_foot_sq : struct pound_force_per_foot_sq :
named_scaled_unit<pound_force_per_foot_sq, "lbf ft2", si::prefix, ratio(32'174'049, 1'000'000), named_scaled_unit<pound_force_per_foot_sq, "lbf ft2", si::prefix, as_magnitude<ratio(32'174'049, 1'000'000)>(),
poundal_per_foot_sq> {}; poundal_per_foot_sq> {};
struct pound_force_per_inch_sq : struct pound_force_per_inch_sq :
named_scaled_unit<pound_force_per_inch_sq, "psi", si::prefix, ratio(1, 144), pound_force_per_foot_sq> {}; named_scaled_unit<pound_force_per_inch_sq, "psi", si::prefix, as_magnitude<ratio(1, 144)>(),
pound_force_per_foot_sq> {};
struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq, si::kilo, pound_force_per_inch_sq> {}; struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq, si::kilo, pound_force_per_inch_sq> {};

2
src/systems/si-hep/include/units/isq/si/hep/area.h
View File

@@ -37,7 +37,7 @@ namespace units::isq::si::hep {
// effective cross-sectional area according to EU council directive 80/181/EEC // effective cross-sectional area according to EU council directive 80/181/EEC
// https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:01980L0181-20090527#page=10 // https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:01980L0181-20090527#page=10
// https://www.fedlex.admin.ch/eli/cc/1994/3109_3109_3109/de // https://www.fedlex.admin.ch/eli/cc/1994/3109_3109_3109/de
struct barn : named_scaled_unit<barn, "b", prefix, ratio(1, 1, -28), square_metre> {}; struct barn : named_scaled_unit<barn, "b", prefix, as_magnitude<ratio(1, 1, -28)>(), square_metre> {};
struct yocto_barn : prefixed_unit<yocto_barn, yocto, barn> {}; struct yocto_barn : prefixed_unit<yocto_barn, yocto, barn> {};
struct zepto_barn : prefixed_unit<zepto_barn, zepto, barn> {}; struct zepto_barn : prefixed_unit<zepto_barn, zepto, barn> {};
struct atto_barn : prefixed_unit<atto_barn, atto, barn> {}; struct atto_barn : prefixed_unit<atto_barn, atto, barn> {};

15
src/systems/si-hep/include/units/isq/si/hep/mass.h
View File

@@ -32,11 +32,15 @@
#include <units/isq/si/mass.h> #include <units/isq/si/mass.h>
#include <units/unit.h> #include <units/unit.h>
// Necessary to factor `1'672'621'923'695`, which appears in the proton mass.
template<>
inline constexpr std::optional<std::intmax_t> units::known_first_factor<334'524'384'739> = 334'524'384'739;
namespace units::isq::si::hep { namespace units::isq::si::hep {
struct eV_per_c2 : struct eV_per_c2 :
named_scaled_unit<eV_per_c2, basic_symbol_text{"eV/c²", "eV/c^2"}, prefix, named_scaled_unit<eV_per_c2, basic_symbol_text{"eV/c²", "eV/c^2"}, prefix,
ratio(1'7826'619'216'279, 1'000'000'000'000, -35), kilogram> {}; as_magnitude<ratio(1'7826'619'216'279, 1'000'000'000'000, -35)>(), kilogram> {};
struct feV_per_c2 : prefixed_unit<feV_per_c2, femto, eV_per_c2> {}; struct feV_per_c2 : prefixed_unit<feV_per_c2, femto, eV_per_c2> {};
struct peV_per_c2 : prefixed_unit<peV_per_c2, pico, eV_per_c2> {}; struct peV_per_c2 : prefixed_unit<peV_per_c2, pico, eV_per_c2> {};
struct neV_per_c2 : prefixed_unit<neV_per_c2, nano, eV_per_c2> {}; struct neV_per_c2 : prefixed_unit<neV_per_c2, nano, eV_per_c2> {};
@@ -52,11 +56,14 @@ struct PeV_per_c2 : prefixed_unit<PeV_per_c2, peta, eV_per_c2> {};
struct EeV_per_c2 : prefixed_unit<EeV_per_c2, exa, eV_per_c2> {}; struct EeV_per_c2 : prefixed_unit<EeV_per_c2, exa, eV_per_c2> {};
struct YeV_per_c2 : prefixed_unit<YeV_per_c2, yotta, eV_per_c2> {}; struct YeV_per_c2 : prefixed_unit<YeV_per_c2, yotta, eV_per_c2> {};
struct electron_mass : struct electron_mass :
named_scaled_unit<eV_per_c2, "m_e", prefix, ratio(9'109'383'701'528, 1'000'000'000'000, -31), kilogram> {}; named_scaled_unit<eV_per_c2, "m_e", prefix, as_magnitude<ratio(9'109'383'701'528, 1'000'000'000'000, -31)>(),
kilogram> {};
struct proton_mass : struct proton_mass :
named_scaled_unit<eV_per_c2, "m_p", prefix, ratio(1'672'621'923'695, 1'000'000'000'000, -27), kilogram> {}; named_scaled_unit<eV_per_c2, "m_p", prefix, as_magnitude<ratio(1'672'621'923'695, 1'000'000'000'000, -27)>(),
kilogram> {};
struct neutron_mass : struct neutron_mass :
named_scaled_unit<eV_per_c2, "m_n", prefix, ratio(1'674'927'498'049, 1'000'000'000'000, -27), kilogram> {}; named_scaled_unit<eV_per_c2, "m_n", prefix, as_magnitude<ratio(1'674'927'498'049, 1'000'000'000'000, -27)>(),
kilogram> {};
struct dim_mass : isq::dim_mass<eV_per_c2> {}; struct dim_mass : isq::dim_mass<eV_per_c2> {};

2
src/systems/si-hep/include/units/isq/si/hep/momentum.h
View File

@@ -36,7 +36,7 @@
namespace units::isq::si::hep { namespace units::isq::si::hep {
struct eV_per_c : struct eV_per_c :
named_scaled_unit<eV_per_c, "eV/c", prefix, ratio(5'344'285'992'678, 1'000'000'000'000, -35), named_scaled_unit<eV_per_c, "eV/c", prefix, as_magnitude<ratio(5'344'285'992'678, 1'000'000'000'000, -35)>(),
::units::isq::si::kilogram_metre_per_second> {}; ::units::isq::si::kilogram_metre_per_second> {};
struct feV_per_c : prefixed_unit<feV_per_c, femto, eV_per_c> {}; struct feV_per_c : prefixed_unit<feV_per_c, femto, eV_per_c> {};
struct peV_per_c : prefixed_unit<peV_per_c, pico, eV_per_c> {}; struct peV_per_c : prefixed_unit<peV_per_c, pico, eV_per_c> {};

6
src/systems/si-iau/include/units/isq/si/iau/length.h
View File

@@ -36,13 +36,13 @@
namespace units::isq::si::iau { namespace units::isq::si::iau {
// https://en.wikipedia.org/wiki/Light-year // https://en.wikipedia.org/wiki/Light-year
struct light_year : named_scaled_unit<light_year, "ly", no_prefix, ratio(9460730472580800), si::metre> {}; struct light_year : named_scaled_unit<light_year, "ly", no_prefix, as_magnitude<9460730472580800>(), si::metre> {};
// https://en.wikipedia.org/wiki/Parsec // https://en.wikipedia.org/wiki/Parsec
struct parsec : named_scaled_unit<parsec, "pc", si::prefix, ratio(30'856'775'814'913'673), si::metre> {}; struct parsec : named_scaled_unit<parsec, "pc", si::prefix, as_magnitude<30'856'775'814'913'673>(), si::metre> {};
// https://en.wikipedia.org/wiki/Angstrom // https://en.wikipedia.org/wiki/Angstrom
struct angstrom : named_scaled_unit<angstrom, "angstrom", no_prefix, ratio(1, 1, -10), si::metre> {}; struct angstrom : named_scaled_unit<angstrom, "angstrom", no_prefix, as_magnitude<ratio(1, 1, -10)>(), si::metre> {};
#ifndef UNITS_NO_LITERALS #ifndef UNITS_NO_LITERALS

4
src/systems/si-imperial/include/units/isq/si/imperial/length.h
View File

@@ -35,10 +35,10 @@
namespace units::isq::si::imperial { namespace units::isq::si::imperial {
// https://en.wikipedia.org/wiki/Chain_(unit) // https://en.wikipedia.org/wiki/Chain_(unit)
struct chain : named_scaled_unit<chain, "ch", no_prefix, ratio(22, 1), si::international::yard> {}; struct chain : named_scaled_unit<chain, "ch", no_prefix, as_magnitude<22>(), si::international::yard> {};
// https://en.wikipedia.org/wiki/Rod_(unit) // https://en.wikipedia.org/wiki/Rod_(unit)
struct rod : named_scaled_unit<rod, "rd", no_prefix, ratio(1, 4), chain> {}; struct rod : named_scaled_unit<rod, "rd", no_prefix, as_magnitude<ratio(1, 4)>(), chain> {};
#ifndef UNITS_NO_LITERALS #ifndef UNITS_NO_LITERALS

14
src/systems/si-international/include/units/isq/si/international/length.h
View File

@@ -37,30 +37,30 @@ namespace units::isq::si::international {
// si::international yard // si::international yard
// https://en.wikipedia.org/wiki/International_yard_and_pound // https://en.wikipedia.org/wiki/International_yard_and_pound
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(9'144, 1'000, -1), si::metre> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<ratio(9'144, 1'000, -1)>(), si::metre> {};
// si::international foot // si::international foot
// https://en.wikipedia.org/wiki/Foot_(unit)#International_foot // https://en.wikipedia.org/wiki/Foot_(unit)#International_foot
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(1, 3), yard> {}; struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(1, 3)>(), yard> {};
// https://en.wikipedia.org/wiki/Fathom#International_fathom // https://en.wikipedia.org/wiki/Fathom#International_fathom
struct fathom : named_scaled_unit<fathom, "fathom", no_prefix, ratio(2), yard> {}; struct fathom : named_scaled_unit<fathom, "fathom", no_prefix, as_magnitude<2>(), yard> {};
// si::international inch // si::international inch
// https://en.wikipedia.org/wiki/Inch#Equivalences // https://en.wikipedia.org/wiki/Inch#Equivalences
struct inch : named_scaled_unit<inch, "in", no_prefix, ratio(1, 36), yard> {}; struct inch : named_scaled_unit<inch, "in", no_prefix, as_magnitude<ratio(1, 36)>(), yard> {};
// intrnational mile // intrnational mile
// https://en.wikipedia.org/wiki/Mile#International_mile // https://en.wikipedia.org/wiki/Mile#International_mile
struct mile : named_scaled_unit<mile, "mi", no_prefix, ratio(25'146, 15'625), si::kilometre> {}; struct mile : named_scaled_unit<mile, "mi", no_prefix, as_magnitude<ratio(25'146, 15'625)>(), si::kilometre> {};
// si::international nautical mile // si::international nautical mile
// https://en.wikipedia.org/wiki/Nautical_mile // https://en.wikipedia.org/wiki/Nautical_mile
struct nautical_mile : named_scaled_unit<nautical_mile, "mi(naut)", no_prefix, ratio(1852), si::metre> {}; struct nautical_mile : named_scaled_unit<nautical_mile, "mi(naut)", no_prefix, as_magnitude<1852>(), si::metre> {};
// thou // thou
// https://en.wikipedia.org/wiki/Thousandth_of_an_inch // https://en.wikipedia.org/wiki/Thousandth_of_an_inch
struct thou : named_scaled_unit<thou, "thou", no_prefix, ratio(1, 1000), inch> {}; struct thou : named_scaled_unit<thou, "thou", no_prefix, as_magnitude<ratio(1, 1000)>(), inch> {};
// mil - different name for thou // mil - different name for thou
// https://en.wikipedia.org/wiki/Thousandth_of_an_inch // https://en.wikipedia.org/wiki/Thousandth_of_an_inch

12
src/systems/si-typographic/include/units/isq/si/typographic/length.h
View File

@@ -37,10 +37,14 @@ namespace units::isq::si::typographic {
// TODO Conflicts with (https://en.wikipedia.org/wiki/Pica_(typography)), verify correctness of below conversion factors // TODO Conflicts with (https://en.wikipedia.org/wiki/Pica_(typography)), verify correctness of below conversion factors
// and provide hyperlinks to definitions // and provide hyperlinks to definitions
struct pica_comp : named_scaled_unit<pica_comp, "pica(comp)", no_prefix, ratio(4233333, 1000000, -3), si::metre> {}; struct pica_comp :
struct pica_prn : named_scaled_unit<pica_prn, "pica(prn)", no_prefix, ratio(2108759, 500000, -3), si::metre> {}; named_scaled_unit<pica_comp, "pica(comp)", no_prefix, as_magnitude<ratio(4233333, 1000000, -3)>(), si::metre> {};
struct point_comp : named_scaled_unit<point_comp, "point(comp)", no_prefix, ratio(1763889, 500000, -4), si::metre> {}; struct pica_prn :
struct point_prn : named_scaled_unit<point_prn, "point(prn)", no_prefix, ratio(1757299, 500000, -4), si::metre> {}; named_scaled_unit<pica_prn, "pica(prn)", no_prefix, as_magnitude<ratio(2108759, 500000, -3)>(), si::metre> {};
struct point_comp :
named_scaled_unit<point_comp, "point(comp)", no_prefix, as_magnitude<ratio(1763889, 500000, -4)>(), si::metre> {};
struct point_prn :
named_scaled_unit<point_prn, "point(prn)", no_prefix, as_magnitude<ratio(1757299, 500000, -4)>(), si::metre> {};
#ifndef UNITS_NO_LITERALS #ifndef UNITS_NO_LITERALS

6
src/systems/si-uscs/include/units/isq/si/uscs/length.h
View File

@@ -36,14 +36,14 @@ namespace units::isq::si::uscs {
// https://en.wikipedia.org/wiki/Foot_(unit)#US_survey_foot // https://en.wikipedia.org/wiki/Foot_(unit)#US_survey_foot
// https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6 // https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6
struct foot : named_scaled_unit<foot, "ft(us)", no_prefix, ratio(1'200, 3'937), si::metre> {}; struct foot : named_scaled_unit<foot, "ft(us)", no_prefix, as_magnitude<ratio(1'200, 3'937)>(), si::metre> {};
// https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6 // https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6
struct fathom : named_scaled_unit<fathom, "fathom(us)", no_prefix, ratio(6), foot> {}; struct fathom : named_scaled_unit<fathom, "fathom(us)", no_prefix, as_magnitude<6>(), foot> {};
// https://en.wikipedia.org/wiki/Mile#U.S._survey_mile // https://en.wikipedia.org/wiki/Mile#U.S._survey_mile
// https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6 // https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors#B6
struct mile : named_scaled_unit<mile, "mi(us)", no_prefix, ratio(5280), foot> {}; struct mile : named_scaled_unit<mile, "mi(us)", no_prefix, as_magnitude<5280>(), foot> {};
#ifndef UNITS_NO_LITERALS #ifndef UNITS_NO_LITERALS

2
src/systems/si/include/units/isq/si/catalytic_activity.h
View File

@@ -58,7 +58,7 @@ struct exakatal : prefixed_unit<exakatal, exa, katal> {};
struct zettakatal : prefixed_unit<zettakatal, zetta, katal> {}; struct zettakatal : prefixed_unit<zettakatal, zetta, katal> {};
struct yottakatal : prefixed_unit<yottakatal, yotta, katal> {}; struct yottakatal : prefixed_unit<yottakatal, yotta, katal> {};
struct enzyme_unit : named_scaled_unit<enzyme_unit, "U", prefix, ratio(1, 60, -6), katal> {}; struct enzyme_unit : named_scaled_unit<enzyme_unit, "U", prefix, as_magnitude<ratio(1, 60, -6)>(), katal> {};
struct dim_catalytic_activity : struct dim_catalytic_activity :
isq::dim_catalytic_activity<dim_catalytic_activity, katal, dim_time, dim_amount_of_substance> {}; isq::dim_catalytic_activity<dim_catalytic_activity, katal, dim_time, dim_amount_of_substance> {};

3
src/systems/si/include/units/isq/si/energy.h
View File

@@ -55,7 +55,8 @@ struct yottajoule : prefixed_unit<yottajoule, yotta, joule> {};
// N.B. electron charge (and eV) is an exact constant: // N.B. electron charge (and eV) is an exact constant:
// https://www.bipm.org/documents/20126/41483022/SI-Brochure-9.pdf#page=147 // https://www.bipm.org/documents/20126/41483022/SI-Brochure-9.pdf#page=147
struct electronvolt : named_scaled_unit<electronvolt, "eV", prefix, ratio(1'602'176'634, 1'000'000'000, -19), joule> {}; struct electronvolt :
named_scaled_unit<electronvolt, "eV", prefix, as_magnitude<ratio(1'602'176'634, 1'000'000'000, -19)>(), joule> {};
struct gigaelectronvolt : prefixed_unit<gigaelectronvolt, giga, electronvolt> {}; struct gigaelectronvolt : prefixed_unit<gigaelectronvolt, giga, electronvolt> {};
struct dim_energy : isq::dim_energy<dim_energy, joule, dim_force, dim_length> {}; struct dim_energy : isq::dim_energy<dim_energy, joule, dim_force, dim_length> {};

3
src/systems/si/include/units/isq/si/length.h
View File

@@ -56,7 +56,8 @@ struct exametre : prefixed_unit<exametre, exa, metre> {};
struct zettametre : prefixed_unit<zettametre, zetta, metre> {}; struct zettametre : prefixed_unit<zettametre, zetta, metre> {};
struct yottametre : prefixed_unit<yottametre, yotta, metre> {}; struct yottametre : prefixed_unit<yottametre, yotta, metre> {};
struct astronomical_unit : named_scaled_unit<astronomical_unit, "au", no_prefix, ratio(149'597'870'700), metre> {}; struct astronomical_unit :
named_scaled_unit<astronomical_unit, "au", no_prefix, as_magnitude<149'597'870'700>(), metre> {};
struct dim_length : isq::dim_length<metre> {}; struct dim_length : isq::dim_length<metre> {};

2
src/systems/si/include/units/isq/si/magnetic_induction.h
View File

@@ -56,7 +56,7 @@ struct exatesla : prefixed_unit<exatesla, exa, tesla> {};
struct zettatesla : prefixed_unit<zettatesla, zetta, tesla> {}; struct zettatesla : prefixed_unit<zettatesla, zetta, tesla> {};
struct yottatesla : prefixed_unit<yottatesla, yotta, tesla> {}; struct yottatesla : prefixed_unit<yottatesla, yotta, tesla> {};
struct gauss : named_scaled_unit<gauss, "G", prefix, ratio(1, 10'000), tesla> {}; struct gauss : named_scaled_unit<gauss, "G", prefix, as_magnitude<ratio(1, 10'000)>(), tesla> {};
struct dim_magnetic_induction : struct dim_magnetic_induction :
isq::dim_magnetic_induction<dim_magnetic_induction, tesla, dim_voltage, dim_time, dim_length> {}; isq::dim_magnetic_induction<dim_magnetic_induction, tesla, dim_voltage, dim_time, dim_length> {};

3
src/systems/si/include/units/isq/si/mass.h
View File

@@ -79,7 +79,8 @@ struct zettatonne : prefixed_unit<zettatonne, zetta, tonne> {};
struct yottatonne : prefixed_unit<yottatonne, yotta, tonne> {}; struct yottatonne : prefixed_unit<yottatonne, yotta, tonne> {};
struct dalton : struct dalton :
named_scaled_unit<dalton, "Da", no_prefix, ratio(16'605'390'666'050, 10'000'000'000'000, -27), kilogram> {}; named_scaled_unit<dalton, "Da", no_prefix, as_magnitude<ratio(16'605'390'666'050, 10'000'000'000'000, -27)>(),
kilogram> {};
struct dim_mass : isq::dim_mass<kilogram> {}; struct dim_mass : isq::dim_mass<kilogram> {};

6
src/systems/si/include/units/isq/si/time.h
View File

@@ -43,9 +43,9 @@ struct picosecond : prefixed_unit<picosecond, pico, second> {};
struct nanosecond : prefixed_unit<nanosecond, nano, second> {}; struct nanosecond : prefixed_unit<nanosecond, nano, second> {};
struct microsecond : prefixed_unit<microsecond, micro, second> {}; struct microsecond : prefixed_unit<microsecond, micro, second> {};
struct millisecond : prefixed_unit<millisecond, milli, second> {}; struct millisecond : prefixed_unit<millisecond, milli, second> {};
struct minute : named_scaled_unit<minute, "min", no_prefix, ratio(60), second> {}; struct minute : named_scaled_unit<minute, "min", no_prefix, as_magnitude<60>(), second> {};
struct hour : named_scaled_unit<hour, "h", no_prefix, ratio(60), minute> {}; struct hour : named_scaled_unit<hour, "h", no_prefix, as_magnitude<60>(), minute> {};
struct day : named_scaled_unit<day, "d", no_prefix, ratio(24), hour> {}; struct day : named_scaled_unit<day, "d", no_prefix, as_magnitude<24>(), hour> {};
struct dim_time : isq::dim_time<second> {}; struct dim_time : isq::dim_time<second> {};

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

@@ -84,7 +84,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("in terms of base units") SECTION("in terms of base units")
{ {
const length<scaled_unit<ratio(1, 1, 6), metre>> q(123); const length<scaled_unit<pow<6>(as_magnitude<10>()), metre>> q(123);
os << q; os << q;
SECTION("iostream") { CHECK(os.str() == "123 Mm"); } SECTION("iostream") { CHECK(os.str() == "123 Mm"); }
@@ -96,7 +96,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("in terms of derived units") SECTION("in terms of derived units")
{ {
const energy<scaled_unit<ratio(1, 1, -2), joule>> q(60); const energy<scaled_unit<pow<-2>(as_magnitude<10>()), joule>> q(60);
os << q; os << q;
SECTION("iostream") { CHECK(os.str() == "60 cJ"); } SECTION("iostream") { CHECK(os.str() == "60 cJ"); }
@@ -257,7 +257,8 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
const auto q = 60_q_kJ / 2_q_min; const auto q = 60_q_kJ / 2_q_min;
os << q; os << q;
SECTION("iostream") { CHECK(os.str() == "30 [1/6 × 10²] W"); } // TODO(chogg): Reinstate after format/Magnitude design.
// SECTION("iostream") { CHECK(os.str() == "30 [1/6 × 10²] W"); }
SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); } SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); }
@@ -390,7 +391,8 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
const auto q = 60_q_min / 2_q_km; const auto q = 60_q_min / 2_q_km;
os << q; os << q;
SECTION("iostream") { CHECK(os.str() == "30 [6 × 10⁻²] 1/m ⋅ s"); } // TODO(chogg): Reinstate after format/Magnitude design.
// SECTION("iostream") { CHECK(os.str() == "30 [6 × 10⁻²] 1/m ⋅ s"); }
SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); } SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); }

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

@@ -30,6 +30,7 @@
#include <units/isq/si/si.h> #include <units/isq/si/si.h>
#include <units/isq/si/typographic/typographic.h> #include <units/isq/si/typographic/typographic.h>
#include <units/isq/si/uscs/uscs.h> #include <units/isq/si/uscs/uscs.h>
#include <units/magnitude.h>
using namespace units::isq::si; using namespace units::isq::si;
using namespace units::isq::si::references; using namespace units::isq::si::references;
@@ -315,16 +316,18 @@ TEST_CASE("std::format on synthesized unit symbols", "[text][fmt]")
SECTION("incoherent units with powers") SECTION("incoherent units with powers")
{ {
CHECK(STD_FMT::format("{}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³"); // TODO(chogg): Reinstate after format/Magnitude redesign.
CHECK(STD_FMT::format("{}", 1_q_au * 1_q_au) == "1 [2237952291797391849 × 10⁴] m²"); // CHECK(STD_FMT::format("{}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³");
// CHECK(STD_FMT::format("{}", 1_q_au * 1_q_au) == "1 [2237952291797391849 × 10⁴] m²");
CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3"); //
CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_au * 1_q_au) == "1 [2237952291797391849 x 10^4] m^2"); // CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3");
// CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_au * 1_q_au) == "1 [2237952291797391849 x 10^4] m^2");
} }
SECTION("unknown scaled unit with reference different than the dimension's coherent unit") SECTION("unknown scaled unit with reference different than the dimension's coherent unit")
{ {
CHECK(STD_FMT::format("{}", mass<units::scaled_unit<units::ratio(2, 3), gram>>(1)) == "1 [2/3 × 10⁻³] kg"); constexpr auto mag = units::as_magnitude<units::ratio{2, 3}>();
CHECK(STD_FMT::format("{:%Q %Aq}", mass<units::scaled_unit<units::ratio(2, 3), gram>>(1)) == "1 [2/3 x 10^-3] kg"); CHECK(STD_FMT::format("{}", mass<units::scaled_unit<mag, gram>>(1)) == "1 [2/3 × 10⁻³] kg");
CHECK(STD_FMT::format("{:%Q %Aq}", mass<units::scaled_unit<mag, gram>>(1)) == "1 [2/3 x 10^-3] kg");
} }
} }

9
test/unit_test/static/concepts_test.cpp
View File

@@ -53,15 +53,6 @@ static_assert(Prefix<si::kilo>);
static_assert(!Prefix<si::prefix>); static_assert(!Prefix<si::prefix>);
static_assert(!Prefix<std::kilo>); static_assert(!Prefix<std::kilo>);
// UnitRatio
static_assert(UnitRatio<ratio(1000)>);
static_assert(!UnitRatio<ratio(0)>);
// static_assert(UnitRatio<ratio(1000, 0)>); // static_assert in ratio
static_assert(UnitRatio<ratio(-1000, -1)>);
static_assert(!UnitRatio<ratio(-1000, 1)>);
static_assert(!UnitRatio<ratio(1, -1000)>);
// BaseDimension // BaseDimension
static_assert(BaseDimension<si::dim_length>); static_assert(BaseDimension<si::dim_length>);

6
test/unit_test/static/quantity_kind_test.cpp
View File

@@ -456,9 +456,9 @@ concept invalid_compound_assignments =
requires !requires { w *= m; }; requires !requires { w *= m; };
requires !requires { w /= m; }; requires !requires { w /= m; };
requires !requires { w %= m; }; requires !requires { w %= m; };
requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; }; requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; }; requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; }; requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
requires !requires { w %= 1.0; }; requires !requires { w %= 1.0; };
requires !requires { w %= quantity(1.0); }; requires !requires { w %= quantity(1.0); };
requires !requires { w %= 1.0 * (w / w); }; requires !requires { w %= 1.0 * (w / w); };

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

@@ -496,7 +496,7 @@ static_assert(compare<decltype(1_q_m / 1_q_m), dimensionless<one, std::int64_t>>
static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>); static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>);
static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>); static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s), static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>); frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, std::int64_t>>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>); static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>); static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>);
@@ -527,7 +527,7 @@ static_assert(compare<decltype(1_q_m / 1._q_m), dimensionless<one, long double>>
static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>); static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>); static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s), static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>); frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>); static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>); static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>); static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>);
@@ -549,7 +549,7 @@ static_assert(compare<decltype(1._q_m / 1_q_m), dimensionless<one, long double>>
static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>); static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>); static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s), static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>); frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
// different units // different units
static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>); static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
@@ -577,22 +577,25 @@ static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<kilometre, std::int64_t
// different dimensions // different dimensions
static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>); static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<ratio(36, 1, 2), metre>, std::int64_t>>); static_assert(
compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<as_magnitude<ratio(36, 1, 2)>(), metre>, std::int64_t>>);
static_assert( static_assert(
compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>, compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>,
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>); scaled_unit<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>); static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<ratio(1, 60), hertz>, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
static_assert( static_assert(
compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>, compare<decltype(1 / 1_q_min), frequency<scaled_unit<as_magnitude<ratio(1, 60)>(), hertz>, std::int64_t>>);
scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>); static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<ratio(1000), one>, std::int64_t>>); static_assert(compare<decltype(1 / 1_q_km),
quantity<unknown_dimension<exponent<dim_length, -1>>,
scaled_unit<as_magnitude<ratio(1, 1, -3)>(), unknown_coherent_unit>, std::int64_t>>);
static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<as_magnitude<1000>(), one>, std::int64_t>>);
static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>); static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>);
static_assert(compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<ratio(1, 60), metre_per_second>, std::int64_t>>); static_assert(
compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<as_magnitude<ratio(1, 60)>(), metre_per_second>, std::int64_t>>);
static_assert( static_assert(
compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>, compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>,
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>); scaled_unit<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
static_assert((1_q_m + 1_q_m).number() == 2); static_assert((1_q_m + 1_q_m).number() == 2);
static_assert((1_q_m + 1_q_km).number() == 1001); static_assert((1_q_m + 1_q_km).number() == 1001);
@@ -882,8 +885,9 @@ static_assert(!is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<cubic_d
static_assert(is_same_v<decltype(10_q_m / 5_q_s), static_assert(is_same_v<decltype(10_q_m / 5_q_s),
quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>, quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>); scaled_unit<as_magnitude<1>(), unknown_coherent_unit>, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>); static_assert(
is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<as_magnitude<ratio(1, 1, -3)>(), metre>, std::int64_t>>);
#else #else
@@ -913,7 +917,8 @@ static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
static_assert(same(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m)); static_assert(same(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
static_assert(same(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km)); static_assert(same(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
static_assert(same(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km)); static_assert(same(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)), static_assert(
3 * km)); same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<as_magnitude<ratio(1, 1000)>(), one>, int>(400)),
3 * km));
} // namespace } // namespace

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

@@ -43,7 +43,7 @@ static_assert(1_q_au == 149'597'870'700_q_m);
static_assert(1_q_km + 1_q_m == 1001_q_m); static_assert(1_q_km + 1_q_m == 1001_q_m);
static_assert(10_q_km / 5_q_km == 2); static_assert(10_q_km / 5_q_km == 2);
static_assert(10_q_km / 5_q_km < 3); static_assert(10_q_km / 5_q_km < 3);
static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<ratio(1, 1, -1), one>>(20)); static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<as_magnitude<ratio(1, 10)>(), one>>(20));
static_assert(100_q_mm / 5_q_cm == dimensionless<one>(2)); static_assert(100_q_mm / 5_q_cm == dimensionless<one>(2));
static_assert(10_q_km / 2 == 5_q_km); static_assert(10_q_km / 2 == 5_q_km);
@@ -107,7 +107,7 @@ static_assert(1000 / 1_q_s == 1_q_kHz);
static_assert(1 / 1_q_ms == 1_q_kHz); static_assert(1 / 1_q_ms == 1_q_kHz);
static_assert(3.2_q_GHz == 3'200'000'000_q_Hz); static_assert(3.2_q_GHz == 3'200'000'000_q_Hz);
static_assert((10_q_Hz * 1_q_min).number() == 10); static_assert((10_q_Hz * 1_q_min).number() == 10);
static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<ratio(60), one>>(10)); static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<as_magnitude<60>(), one>>(10));
static_assert(10_q_Hz * 1_q_min == dimensionless<one>(600)); static_assert(10_q_Hz * 1_q_min == dimensionless<one>(600));
static_assert(2 / 1_q_Hz == 2_q_s); static_assert(2 / 1_q_Hz == 2_q_s);

30
test/unit_test/static/unit_test.cpp
View File

@@ -36,12 +36,12 @@ using namespace units::isq;
struct metre : named_unit<metre, "m", si::prefix> {}; struct metre : named_unit<metre, "m", si::prefix> {};
struct centimetre : prefixed_unit<centimetre, si::centi, metre> {}; struct centimetre : prefixed_unit<centimetre, si::centi, metre> {};
struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {}; struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(9'144, 1, -4), metre> {}; struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<ratio(9'144, 1, -4)>(), metre> {};
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(1, 3), yard> {}; struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(1, 3)>(), yard> {};
struct dim_length : base_dimension<"length", metre> {}; struct dim_length : base_dimension<"length", metre> {};
struct second : named_unit<second, "s", si::prefix> {}; struct second : named_unit<second, "s", si::prefix> {};
struct hour : named_scaled_unit<hour, "h", no_prefix, ratio(36, 1, 2), second> {}; struct hour : named_scaled_unit<hour, "h", no_prefix, as_magnitude<ratio(36, 1, 2)>(), second> {};
struct dim_time : base_dimension<"time", second> {}; struct dim_time : base_dimension<"time", second> {};
struct kelvin : named_unit<kelvin, "K", no_prefix> {}; struct kelvin : named_unit<kelvin, "K", no_prefix> {};
@@ -59,17 +59,21 @@ struct kilometre_per_hour : derived_unit<kilometre_per_hour, dim_speed, kilometr
static_assert(equivalent<metre::named_unit, metre>); static_assert(equivalent<metre::named_unit, metre>);
static_assert(equivalent<metre::scaled_unit, metre>); static_assert(equivalent<metre::scaled_unit, metre>);
static_assert(compare<downcast<scaled_unit<ratio(1), metre>>, metre>); static_assert(compare<downcast<scaled_unit<as_magnitude<1>(), metre>>, metre>);
static_assert(compare<downcast<scaled_unit<ratio(1, 1, -2), metre>>, centimetre>); static_assert(compare<downcast<scaled_unit<as_magnitude<ratio(1, 1, -2)>(), metre>>, centimetre>);
static_assert(compare<downcast<scaled_unit<ratio(yard::ratio.num, yard::ratio.den, yard::ratio.exp), metre>>, yard>); static_assert(
static_assert(compare<downcast<scaled_unit<yard::ratio * ratio(1, 3), metre>>, foot>); compare<downcast<scaled_unit<as_magnitude<ratio(yard::ratio.num, yard::ratio.den, yard::ratio.exp)>(), metre>>,
static_assert(compare<downcast<scaled_unit<kilometre::ratio / hour::ratio, metre_per_second>>, kilometre_per_hour>); yard>);
static_assert(compare<downcast<scaled_unit<yard::mag / as_magnitude<3>(), metre>>, foot>);
static_assert(compare<downcast<scaled_unit<kilometre::mag / hour::mag, metre_per_second>>, kilometre_per_hour>);
#if !UNITS_COMP_MSVC // We should delete this test case, because we are switching from ratio to Magnitude, and a negative Magnitude cannot
static_assert([]<ratio R>() { // even be formed.
return !requires { typename scaled_unit<R, metre>; }; // #if !UNITS_COMP_MSVC
}.template operator()<ratio(-1, 1)>()); // negative unit ratio // static_assert([]<ratio R>() {
#endif // return !requires { typename scaled_unit<R, metre>; };
// }.template operator()<as_magnitude<ratio(-1, 1)>()>()); // negative unit ratio
// #endif
static_assert(centimetre::symbol == "cm"); static_assert(centimetre::symbol == "cm");
static_assert(kilometre::symbol == "km"); static_assert(kilometre::symbol == "km");