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 {
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> {};
@@ -54,8 +54,8 @@ using length = quantity<dim_length, U, Rep>;
namespace fps {
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(3'048, 1'000, -1), metre> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {};
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, as_magnitude<3>(), 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 {
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> {};
@@ -54,8 +54,8 @@ using length = quantity<dim_length, U, Rep>;
namespace fps {
struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(3'048, 1'000, -1), metre> {};
struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(3), foot> {};
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, as_magnitude<3>(), 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<>{});
}
/**
* @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

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/type_traits.h>
#include <units/customization_points.h>
#include <units/ratio.h>
#include <units/magnitude.h>
// IWYU pragma: end_exports
#include <cstdint>
@@ -67,24 +67,15 @@ void to_prefix_base(const volatile prefix_base<PF, R>*);
template<typename 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
template<ratio R, typename U>
requires UnitRatio<R>
template<Magnitude auto M, typename U>
struct scaled_unit;
// TODO: Remove when P1985 accepted
namespace detail {
template<ratio R, typename U>
void to_base_scaled_unit(const volatile scaled_unit<R, U>*);
template<Magnitude auto M, typename U>
void to_base_scaled_unit(const volatile scaled_unit<M, U>*);
} // 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>
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>
requires(same_unit_reference<dimension_unit<D1>, dimension_unit<D2>>::value)
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>
struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
using dimension = conditional<is_specialization_of<D1, unknown_dimension>, D2, D1>;
static constexpr ratio r1 = D1::base_units_ratio * U1::ratio;
static constexpr ratio r2 = D2::base_units_ratio * U2::ratio;
static constexpr ratio cr = common_ratio(r1, r2);
using unit = downcast_unit<dimension, cr / dimension::base_units_ratio>;
static constexpr Magnitude auto m1 = D1::base_units_ratio * U1::mag;
static constexpr Magnitude auto m2 = D2::base_units_ratio * U2::mag;
static constexpr Magnitude auto cm = common_magnitude(m1, m2);
using unit = downcast_unit<dimension, cm / dimension::base_units_ratio>;
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));
}
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>
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>
struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
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;
[[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>
struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> {
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;
[[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...>> {
using recipe = exponent_list<Es...>;
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

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

@@ -31,7 +31,7 @@
namespace units {
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

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);
} else {
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;
return quantity<dim, unit, rep>(
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()); }
{
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 std::sqrt;
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()); }
{
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 std::cbrt;
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/external/downcasting.h>
// IWYU pragma: begin_exports
#include <units/magnitude.h>
#include <units/ratio.h>
#include <units/symbol_text.h>
// IWYU pragma: end_exports
@@ -52,6 +53,7 @@ template<PrefixFamily PF, ratio R>
struct prefix_base : downcast_base<prefix_base<PF, R>> {
using prefix_family = PF;
static constexpr ::units::ratio ratio = R;
static constexpr Magnitude auto mag = as_magnitude<R>();
};
} // namespace detail

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

@@ -402,7 +402,7 @@ public:
{
gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
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>>;
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/concepts.h>
#include <units/customization_points.h>
#include <units/magnitude.h>
UNITS_DIAGNOSTIC_PUSH
// 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 {
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>
inline constexpr ratio quantity_ratio<quantity<D, U, Rep>> = [] {
inline constexpr Magnitude auto quantity_magnitude<quantity<D, U, Rep>> = [] {
if constexpr (BaseDimension<D>) {
return U::ratio;
return U::mag;
} 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>
inline constexpr ratio cast_ratio = [] {
inline constexpr Magnitude auto cast_magnitude = [] {
using FromU = TYPENAME QFrom::unit;
using ToU = TYPENAME QTo::unit;
if constexpr (same_unit_reference<FromU, ToU>::value) {
return FromU::ratio / ToU::ratio;
return FromU::mag / ToU::mag;
} 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 ratio_type = TYPENAME traits::ratio_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>) {
return To(
static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) *
(static_cast<ratio_type>(c_ratio.num) * detail::fpow10<ratio_type>(c_ratio.exp) /
static_cast<ratio_type>(c_ratio.den))));
static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) * (get_value<ratio_type>(numerator(c_mag)) /
get_value<ratio_type>(denominator(c_mag)))));
} else {
if constexpr (c_ratio.exp > 0) {
return To(static_cast<TYPENAME To::rep>(
static_cast<rep_type>(q.number()) *
(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)))));
}
return To(
static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) * get_value<ratio_type>(numerator(c_mag)) /
get_value<ratio_type>(denominator(c_mag))));
}
}
@@ -149,7 +148,7 @@ template<Dimension ToD, typename D, typename U, typename Rep>
requires equivalent<ToD, D>
[[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>
using reference_multiply_impl =
reference<D, downcast_unit<D, (U1::ratio / dimension_unit<D1>::ratio) * (U2::ratio / dimension_unit<D2>::ratio) *
dimension_unit<D>::ratio>>;
reference<D, downcast_unit<D, (U1::mag / dimension_unit<D1>::mag) * (U2::mag / dimension_unit<D2>::mag) *
dimension_unit<D>::mag>>;
template<typename D, typename D1, typename U1, typename D2, typename U2>
using reference_divide_impl =
reference<D, downcast_unit<D, (U1::ratio / dimension_unit<D1>::ratio) / (U2::ratio / dimension_unit<D2>::ratio) *
dimension_unit<D>::ratio>>;
reference<D, downcast_unit<D, (U1::mag / dimension_unit<D1>::mag) / (U2::mag / dimension_unit<D2>::mag) *
dimension_unit<D>::mag>>;
} // namespace detail

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

@@ -28,6 +28,7 @@
// IWYU pragma: begin_exports
#include <units/bits/derived_unit.h>
#include <units/bits/external/fixed_string.h>
#include <units/magnitude.h>
#include <units/prefix.h>
#include <units/ratio.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
* 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
*/
template<ratio R, typename U>
requires UnitRatio<R>
struct scaled_unit : downcast_base<scaled_unit<R, U>> {
static constexpr ::units::ratio ratio = R;
template<Magnitude auto M, typename U>
struct scaled_unit : downcast_base<scaled_unit<M, U>> {
static constexpr ::units::ratio ratio = as_ratio(M);
static constexpr Magnitude auto mag = M;
using reference = U;
};
template<Dimension D, auto R>
// template<Dimension D, ratio R> // TODO: GCC crash!!!
requires UnitRatio<R>
using downcast_unit = downcast<scaled_unit<R, typename dimension_unit<D>::reference>>;
template<Dimension D, Magnitude auto M>
using downcast_unit = downcast<scaled_unit<M, typename dimension_unit<D>::reference>>;
template<Unit U1, Unit U2>
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)
*/
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;
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
*/
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 auto symbol = Symbol;
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 Symbol a short text representation of the unit
* @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
*/
template<typename Child, basic_symbol_text Symbol, PrefixFamily PF, ratio R, Unit U>
requires UnitRatio<R>
struct named_scaled_unit : downcast_dispatch<Child, scaled_unit<R * U::ratio, typename U::reference>> {
template<typename Child, basic_symbol_text Symbol, PrefixFamily PF, Magnitude auto M, Unit U>
struct named_scaled_unit : downcast_dispatch<Child, scaled_unit<M * U::mag, typename U::reference>> {
static constexpr bool is_named = true;
static constexpr auto symbol = Symbol;
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>
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 auto symbol = P::symbol + U::symbol;
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 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 megabyte : prefixed_unit<megabyte, si::mega, 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> {};
// 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> {};

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

@@ -35,24 +35,24 @@
namespace units::isq::si::fps {
// 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
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 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 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> {};

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

@@ -35,28 +35,29 @@
namespace units::isq::si::fps {
// 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> {};
template<UnitOf<dim_mass> U, Representation Rep = double>
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

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 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>
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>;
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> {};
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> {};

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
// 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
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 zepto_barn : prefixed_unit<zepto_barn, zepto, 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/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 {
struct eV_per_c2 :
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 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> {};
@@ -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 YeV_per_c2 : prefixed_unit<YeV_per_c2, yotta, eV_per_c2> {};
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 :
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 :
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> {};

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

@@ -36,7 +36,7 @@
namespace units::isq::si::hep {
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> {};
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> {};

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

@@ -36,13 +36,13 @@
namespace units::isq::si::iau {
// 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
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
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

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

@@ -35,10 +35,10 @@
namespace units::isq::si::imperial {
// 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)
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

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
// 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
// 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
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
// 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
// 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
// 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
// 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
// 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
// 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_prn : named_scaled_unit<pica_prn, "pica(prn)", no_prefix, ratio(2108759, 500000, -3), si::metre> {};
struct point_comp : named_scaled_unit<point_comp, "point(comp)", no_prefix, ratio(1763889, 500000, -4), si::metre> {};
struct point_prn : named_scaled_unit<point_prn, "point(prn)", no_prefix, ratio(1757299, 500000, -4), si::metre> {};
struct pica_comp :
named_scaled_unit<pica_comp, "pica(comp)", no_prefix, as_magnitude<ratio(4233333, 1000000, -3)>(), si::metre> {};
struct pica_prn :
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

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://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
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://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

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 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 :
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:
// 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 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 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> {};

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 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 :
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 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> {};

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 microsecond : prefixed_unit<microsecond, micro, second> {};
struct millisecond : prefixed_unit<millisecond, milli, second> {};
struct minute : named_scaled_unit<minute, "min", no_prefix, ratio(60), second> {};
struct hour : named_scaled_unit<hour, "h", no_prefix, ratio(60), minute> {};
struct day : named_scaled_unit<day, "d", no_prefix, ratio(24), hour> {};
struct minute : named_scaled_unit<minute, "min", no_prefix, as_magnitude<60>(), second> {};
struct hour : named_scaled_unit<hour, "h", no_prefix, as_magnitude<60>(), minute> {};
struct day : named_scaled_unit<day, "d", no_prefix, as_magnitude<24>(), hour> {};
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")
{
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;
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")
{
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;
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;
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()); }
@@ -390,7 +391,8 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
const auto q = 60_q_min / 2_q_km;
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()); }

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/typographic/typographic.h>
#include <units/isq/si/uscs/uscs.h>
#include <units/magnitude.h>
using namespace units::isq::si;
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")
{
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");
// TODO(chogg): Reinstate after format/Magnitude redesign.
// 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");
}
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");
CHECK(STD_FMT::format("{:%Q %Aq}", mass<units::scaled_unit<units::ratio(2, 3), gram>>(1)) == "1 [2/3 x 10^-3] kg");
constexpr auto mag = units::as_magnitude<units::ratio{2, 3}>();
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<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
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 *= 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<ratio{1, 1, 3}, 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<as_magnitude<1000>(), 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 %= quantity(1.0); };
requires !requires { w %= 1.0 * (w / w); };

35
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(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
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&&>);
@@ -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(quantity{1} / 1._q_s), frequency<hertz, long double>>);
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 % quantity{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(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
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
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
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(
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 / 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(
compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>,
scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<ratio(1000), one>, std::int64_t>>);
compare<decltype(1 / 1_q_min), frequency<scaled_unit<as_magnitude<ratio(1, 60)>(), hertz>, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, 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_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(
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_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),
quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
scaled_unit<ratio(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>>);
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<as_magnitude<ratio(1, 1, -3)>(), metre>, std::int64_t>>);
#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 * 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, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)),
static_assert(
same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<as_magnitude<ratio(1, 1000)>(), one>, int>(400)),
3 * km));
} // 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(10_q_km / 5_q_km == 2);
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(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(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 == 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(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 centimetre : prefixed_unit<centimetre, si::centi, 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 foot : named_scaled_unit<foot, "ft", no_prefix, ratio(1, 3), yard> {};
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, as_magnitude<ratio(1, 3)>(), yard> {};
struct dim_length : base_dimension<"length", metre> {};
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 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::scaled_unit, metre>);
static_assert(compare<downcast<scaled_unit<ratio(1), metre>>, metre>);
static_assert(compare<downcast<scaled_unit<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(compare<downcast<scaled_unit<yard::ratio * ratio(1, 3), metre>>, foot>);
static_assert(compare<downcast<scaled_unit<kilometre::ratio / hour::ratio, metre_per_second>>, kilometre_per_hour>);
static_assert(compare<downcast<scaled_unit<as_magnitude<1>(), metre>>, metre>);
static_assert(compare<downcast<scaled_unit<as_magnitude<ratio(1, 1, -2)>(), metre>>, centimetre>);
static_assert(
compare<downcast<scaled_unit<as_magnitude<ratio(yard::ratio.num, yard::ratio.den, yard::ratio.exp)>(), metre>>,
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
static_assert([]<ratio R>() {
return !requires { typename scaled_unit<R, metre>; };
}.template operator()<ratio(-1, 1)>()); // negative unit ratio
#endif
// We should delete this test case, because we are switching from ratio to Magnitude, and a negative Magnitude cannot
// even be formed.
// #if !UNITS_COMP_MSVC
// static_assert([]<ratio R>() {
// 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(kilometre::symbol == "km");