41# pragma push_macro("pascal")
44# define _ALLOW_KEYWORD_MACROS
46# pragma warning(disable : 4520)
47# pragma push_macro("constexpr")
49# pragma push_macro("noexcept")
50# define noexcept throw()
54#if !defined(_MSC_VER) || _MSC_VER > 1800
55# define UNIT_HAS_LITERAL_SUPPORT
58#ifndef UNIT_LIB_DEFAULT_TYPE
59# define UNIT_LIB_DEFAULT_TYPE double
73#if defined(UNIT_LIB_ENABLE_IOSTREAM)
78#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
94 template <
typename T> std::string
to_string(
const T& t)
102 char decimalPoint = *lc->decimal_point;
103 if (str.find_last_not_of(
'0') == str.find(decimalPoint)) { offset = 0; }
104 str.erase(str.find_last_not_of(
'0') + offset, std::string::npos);
112 template<
typename T>
inline constexpr const char*
name(
const T&);
113 template<
typename T>
inline constexpr const char*
abbreviation(
const T&);
136#define UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, ...)\
137 namespace namespaceName\
139 typedef __VA_ARGS__ namePlural; \
140 typedef namePlural nameSingular; \
141 typedef namePlural abbreviation; \
151#define UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
152 namespace namespaceName\
154 typedef unit_t<nameSingular> nameSingular ## _t; \
165#define UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular, underlyingType)\
166 namespace namespaceName\
168 typedef unit_t<nameSingular,underlyingType> nameSingular ## _t; \
180#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
181 #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
184 struct fmt::formatter<units::namespaceName::nameSingular ## _t> \
185 : fmt::formatter<double> \
187 template <typename FmtContext>\
189 const units::namespaceName::nameSingular ## _t& obj,\
190 FmtContext& ctx) const\
192 auto out = ctx.out();\
193 out = fmt::formatter<double>::format(obj(), ctx);\
194 return fmt::format_to(out, " " #abbrev);\
199 namespace namespaceName\
201 inline std::string to_string(const nameSingular ## _t& obj)\
203 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
207#if defined(UNIT_LIB_ENABLE_IOSTREAM)
208 #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
209 namespace namespaceName\
211 inline std::ostream& operator<<(std::ostream& os, const nameSingular ## _t& obj) \
213 os << obj() << " "#abbrev; return os; \
215 inline std::string to_string(const nameSingular ## _t& obj)\
217 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
232#define UNIT_ADD_NAME(namespaceName, nameSingular, abbrev)\
233template<> inline constexpr const char* name(const namespaceName::nameSingular ## _t&)\
235 return #nameSingular;\
237template<> inline constexpr const char* abbreviation(const namespaceName::nameSingular ## _t&)\
253#if defined(UNIT_HAS_LITERAL_SUPPORT)
254 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)\
257 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation(long double d)\
259 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
261 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation (unsigned long long d)\
263 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
267 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)
289#define UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, ...)\
290 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
291 UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
292 UNIT_ADD_NAME(namespaceName,nameSingular, abbreviation)\
293 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
294 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
316#define UNIT_ADD_WITH_CUSTOM_TYPE(namespaceName, nameSingular, namePlural, abbreviation, underlyingType, ...)\
317 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
318 UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular,underlyingType)\
319 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
320 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
331#define UNIT_ADD_DECIBEL(namespaceName, nameSingular, abbreviation)\
332 namespace namespaceName\
334 typedef unit_t<nameSingular, UNIT_LIB_DEFAULT_TYPE, units::decibel_scale> abbreviation ## _t; \
336 UNIT_ADD_IO(namespaceName, abbreviation, abbreviation)\
337 UNIT_ADD_LITERALS(namespaceName, abbreviation, abbreviation)
348#define UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
354 template<typename T> struct is_ ## unitCategory ## _unit_impl : std::false_type {};\
355 template<typename C, typename U, typename P, typename T>\
356 struct is_ ## unitCategory ## _unit_impl<units::unit<C, U, P, T>> : std::is_same<units::traits::base_unit_of<typename units::traits::unit_traits<units::unit<C, U, P, T>>::base_unit_type>, units::category::unitCategory ## _unit>::type {};\
357 template<typename U, typename S, template<typename> class N>\
358 struct is_ ## unitCategory ## _unit_impl<units::unit_t<U, S, N>> : std::is_same<units::traits::base_unit_of<typename units::traits::unit_t_traits<units::unit_t<U, S, N>>::unit_type>, units::category::unitCategory ## _unit>::type {};\
363#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)\
366 template<typename... T> struct is_ ## unitCategory ## _unit : std::integral_constant<bool, units::all_true<units::traits::detail::is_ ## unitCategory ## _unit_impl<std::decay_t<T>>::value...>::value> {};\
367 template<typename... T> inline constexpr bool is_ ## unitCategory ## _unit_v = is_ ## unitCategory ## _unit<T...>::value;\
369 template <typename T>\
370 concept unitCategory ## _unit = traits::is_ ## unitCategory ## _unit_v<T>;
372#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)\
373 UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
378 UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)
398#define UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
399 UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
400 UNIT_ADD(namespaceName, femto ## nameSingular, femto ## namePlural, f ## abbreviation, femto<namePlural>)\
401 UNIT_ADD(namespaceName, pico ## nameSingular, pico ## namePlural, p ## abbreviation, pico<namePlural>)\
402 UNIT_ADD(namespaceName, nano ## nameSingular, nano ## namePlural, n ## abbreviation, nano<namePlural>)\
403 UNIT_ADD(namespaceName, micro ## nameSingular, micro ## namePlural, u ## abbreviation, micro<namePlural>)\
404 UNIT_ADD(namespaceName, milli ## nameSingular, milli ## namePlural, m ## abbreviation, milli<namePlural>)\
405 UNIT_ADD(namespaceName, centi ## nameSingular, centi ## namePlural, c ## abbreviation, centi<namePlural>)\
406 UNIT_ADD(namespaceName, deci ## nameSingular, deci ## namePlural, d ## abbreviation, deci<namePlural>)\
407 UNIT_ADD(namespaceName, deca ## nameSingular, deca ## namePlural, da ## abbreviation, deca<namePlural>)\
408 UNIT_ADD(namespaceName, hecto ## nameSingular, hecto ## namePlural, h ## abbreviation, hecto<namePlural>)\
409 UNIT_ADD(namespaceName, kilo ## nameSingular, kilo ## namePlural, k ## abbreviation, kilo<namePlural>)\
410 UNIT_ADD(namespaceName, mega ## nameSingular, mega ## namePlural, M ## abbreviation, mega<namePlural>)\
411 UNIT_ADD(namespaceName, giga ## nameSingular, giga ## namePlural, G ## abbreviation, giga<namePlural>)\
412 UNIT_ADD(namespaceName, tera ## nameSingular, tera ## namePlural, T ## abbreviation, tera<namePlural>)\
413 UNIT_ADD(namespaceName, peta ## nameSingular, peta ## namePlural, P ## abbreviation, peta<namePlural>)\
433#define UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
434 UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
435 UNIT_ADD(namespaceName, kibi ## nameSingular, kibi ## namePlural, Ki ## abbreviation, kibi<namePlural>)\
436 UNIT_ADD(namespaceName, mebi ## nameSingular, mebi ## namePlural, Mi ## abbreviation, mebi<namePlural>)\
437 UNIT_ADD(namespaceName, gibi ## nameSingular, gibi ## namePlural, Gi ## abbreviation, gibi<namePlural>)\
438 UNIT_ADD(namespaceName, tebi ## nameSingular, tebi ## namePlural, Ti ## abbreviation, tebi<namePlural>)\
439 UNIT_ADD(namespaceName, pebi ## nameSingular, pebi ## namePlural, Pi ## abbreviation, pebi<namePlural>)\
440 UNIT_ADD(namespaceName, exbi ## nameSingular, exbi ## namePlural, Ei ## abbreviation, exbi<namePlural>)
519 static constexpr const UNIT_LIB_DEFAULT_TYPE PI_VAL = 3.14159265358979323846264338327950288419716939937510;
541 static constexpr auto test(U*)->std::is_integral<
decltype(U::num)> {
return std::is_integral<
decltype(U::num)>{}; }
543 static constexpr std::false_type test(...) {
return std::false_type{}; }
545 using type =
decltype(test<T>(0));
555 struct has_num : units::detail::has_num_impl<T>
::type {};
564 static constexpr auto test(U*)->std::is_integral<
decltype(U::den)> {
return std::is_integral<
decltype(U::den)>{}; }
566 static constexpr std::false_type test(...) {
return std::false_type{}; }
568 using type =
decltype(test<T>(0));
578 struct has_den : units::detail::has_den_impl<T>
::type {};
613 template<
bool...>
struct bool_pack {};
618 template<
bool... Args>
619 struct all_true : std::is_same<units::bool_pack<true, Args...>, units::bool_pack<Args..., true>> {};
620 template<
bool... Args>
621 inline constexpr bool all_true_t_v = all_true<Args...>::type::value;
629#ifdef FOR_DOXYGEN_PURPOSES_ONLY
640 typedef typename T::base_unit_type base_unit_type;
641 typedef typename T::conversion_ratio conversion_ratio;
642 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
643 typedef typename T::translation_ratio translation_ratio;
650 template<
class T,
typename =
void>
653 typedef void base_unit_type;
654 typedef void conversion_ratio;
655 typedef void pi_exponent_ratio;
656 typedef void translation_ratio;
662 typename T::base_unit_type,
663 typename T::conversion_ratio,
664 typename T::pi_exponent_ratio,
665 typename T::translation_ratio>
::type>
667 typedef typename T::base_unit_type base_unit_type;
668 typedef typename T::conversion_ratio conversion_ratio;
669 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
670 typedef typename T::translation_ratio translation_ratio;
682 struct _base_unit_t {};
695 struct is_base_unit : std::is_base_of<units::detail::_base_unit_t, T> {};
707 template<std::
intmax_t Num, std::
intmax_t Den = 1>
708 using meter_ratio = std::ratio<Num, Den>;
750 template<
class Meter = detail::meter_ratio<0>,
751 class Kilogram = std::ratio<0>,
752 class Second = std::ratio<0>,
753 class Radian = std::ratio<0>,
754 class Ampere = std::ratio<0>,
755 class Kelvin = std::ratio<0>,
756 class Mole = std::ratio<0>,
757 class Candela = std::ratio<0>,
758 class Byte = std::ratio<0>>
761 static_assert(
traits::is_ratio<Meter>::value,
"Template parameter `Meter` must be a `std::ratio` representing the exponent of meters the unit has");
763 static_assert(
traits::is_ratio<Second>::value,
"Template parameter `Second` must be a `std::ratio` representing the exponent of seconds the unit has");
764 static_assert(
traits::is_ratio<Ampere>::value,
"Template parameter `Ampere` must be a `std::ratio` representing the exponent of amperes the unit has");
767 static_assert(
traits::is_ratio<Mole>::value,
"Template parameter `Mole` must be a `std::ratio` representing the exponent of moles the unit has");
768 static_assert(
traits::is_ratio<Radian>::value,
"Template parameter `Radian` must be a `std::ratio` representing the exponent of radians the unit has");
769 static_assert(
traits::is_ratio<Byte>::value,
"Template parameter `Byte` must be a `std::ratio` representing the exponent of bytes the unit has");
829 typedef base_unit<detail::meter_ratio<-2>, std::ratio<0>, std::ratio<0>, std::ratio<2>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>
illuminance_unit;
851 template <
class,
class,
class,
class>
struct unit;
852 template<
class Conversion,
class... Exponents,
class PiExponent,
class Translation>
853 struct unit<Conversion,
base_unit<Exponents...>, PiExponent, Translation> : units::detail::_unit
857 static_assert(
traits::is_ratio<Translation>::value,
"Template parameter `Translation` must be a `std::ratio` representing an additive translation required by the unit conversion.");
885 template<
class Conversion,
class BaseUnit,
class PiExponent = std::ratio<0>,
class Translation = std::ratio<0>>
886 struct unit : units::detail::_unit
892 typedef typename units::traits::unit_traits<BaseUnit>::base_unit_type
base_unit_type;
893 typedef typename std::ratio_multiply<typename BaseUnit::conversion_ratio, Conversion>
conversion_ratio;
894 typedef typename std::ratio_add<typename BaseUnit::pi_exponent_ratio, PiExponent>
pi_exponent_ratio;
895 typedef typename std::ratio_add<std::ratio_multiply<typename BaseUnit::conversion_ratio, Translation>,
typename BaseUnit::translation_ratio>
translation_ratio;
910 template<
class>
struct base_unit_of_impl;
911 template<
class Conversion,
class BaseUnit,
class PiExponent,
class Translation>
912 struct base_unit_of_impl<
unit<Conversion, BaseUnit, PiExponent, Translation>> : base_unit_of_impl<BaseUnit> {};
913 template<
class... Exponents>
914 struct base_unit_of_impl<base_unit<Exponents...>>
916 typedef base_unit<Exponents...>
type;
919 struct base_unit_of_impl<void>
946 template<
class,
class>
struct base_unit_multiply_impl;
947 template<
class... Exponents1,
class... Exponents2>
955 template<
class U1,
class U2>
963 template<
class,
class>
struct base_unit_divide_impl;
964 template<
class... Exponents1,
class... Exponents2>
965 struct base_unit_divide_impl<base_unit<Exponents1...>, base_unit<Exponents2...>> {
966 using type = base_unit<std::ratio_subtract<Exponents1, Exponents2>...>;
972 template<
class U1,
class U2>
980 template<
class>
struct inverse_base_impl;
982 template<
class... Exponents>
983 struct inverse_base_impl<base_unit<Exponents...>> {
984 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<-1>>...>;
998 template<
class U>
struct squared_base_impl;
999 template<
class... Exponents>
1000 struct squared_base_impl<base_unit<Exponents...>> {
1001 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<2>>...>;
1015 template<
class U>
struct cubed_base_impl;
1016 template<
class... Exponents>
1017 struct cubed_base_impl<base_unit<Exponents...>> {
1018 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<3>>...>;
1032 template<
class U>
struct sqrt_base_impl;
1033 template<
class... Exponents>
1034 struct sqrt_base_impl<base_unit<Exponents...>> {
1035 using type = base_unit<std::ratio_divide<Exponents, std::ratio<2>>...>;
1049 template<
class U>
struct cbrt_base_impl;
1050 template<
class... Exponents>
1051 struct cbrt_base_impl<base_unit<Exponents...>> {
1052 using type = base_unit<std::ratio_divide<Exponents, std::ratio<3>>...>;
1076 template<
class Unit1,
class Unit2>
1077 struct unit_multiply_impl
1079 using type = unit < std::ratio_multiply<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1080 base_unit_multiply <traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1081 std::ratio_add<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1089 template<
class U1,
class U2>
1098 template<
class Unit1,
class Unit2>
1099 struct unit_divide_impl
1101 using type = unit < std::ratio_divide<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1102 base_unit_divide<traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1103 std::ratio_subtract<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1111 template<
class U1,
class U2>
1120 template<
class Unit>
1123 using type = unit < std::ratio<Unit::conversion_ratio::den, Unit::conversion_ratio::num>,
1124 inverse_base<traits::base_unit_of<typename units::traits::unit_traits<Unit>::base_unit_type>>,
1125 std::ratio_multiply<typename units::traits::unit_traits<Unit>::pi_exponent_ratio, std::ratio<-1>>,
1147 template<
class Unit>
1151 using Conversion =
typename Unit::conversion_ratio;
1153 squared_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1154 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1155 typename Unit::translation_ratio
1178 template<
class Unit>
1182 using Conversion =
typename Unit::conversion_ratio;
1184 cubed_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1185 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<3>>,
1186 typename Unit::translation_ratio> ;
1207 using Zero = std::ratio<0>;
1208 using One = std::ratio<1>;
1209 template <
typename R>
using Square = std::ratio_multiply<R, R>;
1212 template <
template <std::
intmax_t N>
class Predicate,
typename enabled =
void>
1213 struct BinarySearch {
1214 template <std::
intmax_t N>
1215 struct SafeDouble_ {
1216 static constexpr const std::intmax_t value = 2 * N;
1217 static_assert(value > 0,
"Overflows when computing 2 * N");
1220 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1 =
void,
typename Condition2 =
void>
1221 struct DoubleSidedSearch_ : DoubleSidedSearch_<Lower, Upper,
1222 std::integral_constant<bool, (Upper - Lower == 1)>,
1223 std::integral_constant<bool, ((Upper - Lower>1 && Predicate<Lower + (Upper - Lower) / 2>::value))>> {};
1225 template <
intmax_t Lower,
intmax_t Upper>
1226 struct DoubleSidedSearch_<Lower, Upper,
std::false_type, std::false_type> : DoubleSidedSearch_<Lower, Lower + (Upper - Lower) / 2> {};
1228 template <
intmax_t Lower,
intmax_t Upper,
typename Condition2>
1229 struct DoubleSidedSearch_<Lower, Upper,
std::true_type, Condition2> : std::integral_constant<intmax_t, Lower>{};
1231 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1>
1232 struct DoubleSidedSearch_<Lower, Upper, Condition1,
std::true_type> : DoubleSidedSearch_<Lower + (Upper - Lower) / 2, Upper>{};
1234 template <std::
intmax_t Lower,
class enabled1 =
void>
1235 struct SingleSidedSearch_ : SingleSidedSearch_<Lower, std::integral_constant<bool, Predicate<SafeDouble_<Lower>::value>::value>>{};
1237 template <std::
intmax_t Lower>
1238 struct SingleSidedSearch_<Lower,
std::false_type> : DoubleSidedSearch_<Lower, SafeDouble_<Lower>::value> {};
1240 template <std::
intmax_t Lower>
1241 struct SingleSidedSearch_<Lower,
std::true_type> : SingleSidedSearch_<SafeDouble_<Lower>::value>{};
1243 static constexpr const std::intmax_t value = SingleSidedSearch_<1>::value;
1246 template <
template <std::
intmax_t N>
class Predicate>
1247 struct BinarySearch<Predicate,
std::
enable_if_t<!Predicate<1>::value>> : std::integral_constant<std::intmax_t, 0>{};
1250 template <
typename R>
1252 template <std::
intmax_t N>
using Predicate_ = std::ratio_less_equal<std::ratio<N>, std::ratio_divide<R, std::ratio<N>>>;
1253 static constexpr const std::intmax_t value = BinarySearch<Predicate_>::value;
1256 template <
typename R>
1257 struct IsPerfectSquare {
1258 static constexpr const std::intmax_t DenSqrt_ = Integer<std::ratio<R::den>>::value;
1259 static constexpr const std::intmax_t NumSqrt_ = Integer<std::ratio<R::num>>::value;
1260 static constexpr const bool value =( DenSqrt_ * DenSqrt_ == R::den && NumSqrt_ * NumSqrt_ == R::num);
1261 using Sqrt = std::ratio<NumSqrt_, DenSqrt_>;
1265 template <
typename Tp,
typename Tq>
1272 template <
typename R>
1274 using P_ =
typename R::P;
1275 using Q_ =
typename R::Q;
1276 using Den_ = std::ratio_subtract<P_, Square<Q_>>;
1277 using A_ = std::ratio_divide<Q_, Den_>;
1278 using B_ = std::ratio_divide<P_, Square<Den_>>;
1279 static constexpr const std::intmax_t I_ = (A_::num + Integer<std::ratio_multiply<B_, Square<std::ratio<A_::den>>>>::value) / A_::den;
1280 using I = std::ratio<I_>;
1281 using Rem = Remainder<B_, std::ratio_subtract<I, A_>>;
1288 template <
typename Tr, std::
intmax_t N>
1289 struct ContinuedFraction {
1290 template <
typename T>
1291 using Abs_ = std::conditional_t<std::ratio_less<T, Zero>::value, std::ratio_subtract<Zero, T>, T>;
1294 using Last_ = ContinuedFraction<
R, N - 1>;
1295 using Reciprocal_ = Reciprocal<typename Last_::Rem>;
1296 using Rem =
typename Reciprocal_::Rem;
1297 using I_ =
typename Reciprocal_::I;
1298 using Den_ = std::ratio_add<typename Last_::W, I_>;
1299 using U = std::ratio_divide<typename Last_::V, Den_>;
1300 using V = std::ratio_divide<std::ratio_add<typename Last_::U, std::ratio_multiply<typename Last_::V, I_>>, Den_>;
1301 using W = std::ratio_divide<One, Den_>;
1302 using Error = Abs_<std::ratio_divide<std::ratio_subtract<U, std::ratio_multiply<V, W>>,
typename Reciprocal<Rem>::I>>;
1305 template <
typename Tr>
1306 struct ContinuedFraction<Tr, 1> {
1309 using V = std::ratio<Integer<R>::value>;
1311 using Rem = Remainder<R, V>;
1312 using Error = std::ratio_divide<One, typename Reciprocal<Rem>::I>;
1315 template <
typename R,
typename Eps, std::
intmax_t N = 1,
typename enabled =
void>
1316 struct Sqrt_ : Sqrt_<R, Eps, N + 1> {};
1318 template <
typename R,
typename Eps, std::
intmax_t N>
1319 struct Sqrt_<
R, Eps, N,
std::
enable_if_t<std::ratio_less_equal<typename ContinuedFraction<R, N>::Error, Eps>::value>> {
1320 using type =
typename ContinuedFraction<R, N>::V;
1323 template <
typename R,
typename Eps,
typename enabled =
void>
1325 static_assert(std::ratio_greater_equal<R, Zero>::value,
"R can't be negative");
1328 template <
typename R,
typename Eps>
1329 struct Sqrt<
R, Eps,
std::
enable_if_t<std::ratio_greater_equal<R, Zero>::value && IsPerfectSquare<R>::value>> {
1330 using type =
typename IsPerfectSquare<R>::Sqrt;
1333 template <
typename R,
typename Eps>
1334 struct Sqrt<
R, Eps,
std::
enable_if_t<(std::ratio_greater_equal<R, Zero>::value && !IsPerfectSquare<R>::value)>> : Sqrt_<R, Eps>{};
1358 template<
typename Ratio, std::
intmax_t Eps = 10000000000>
1369 template<
class Unit, std::
intmax_t Eps>
1373 using Conversion =
typename Unit::conversion_ratio;
1375 sqrt_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1376 std::ratio_divide<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1377 typename Unit::translation_ratio>;
1403 template<
class U, std::
intmax_t Eps = 10000000000>
1418 template<
class U,
class... Us>
struct compound_impl;
1419 template<
class U>
struct compound_impl<U> {
using type = U; };
1420 template<
class U1,
class U2,
class...Us>
1421 struct compound_impl<U1, U2, Us...>
1422 : compound_impl<unit_multiply<U1, U2>, Us...> {};
1436 template<
class U,
class... Us>
1450 template<
class Ratio,
class Unit>
1459 template <
int N,
class U>
1460 struct power_of_ratio
1462 typedef std::ratio_multiply<U,
typename power_of_ratio<N - 1, U>
::type>
type;
1467 struct power_of_ratio<1, U>
1504 template<
class U>
using kibi =
typename units::detail::prefix<std::ratio<1024>, U>
::type;
1505 template<
class U>
using mebi =
typename units::detail::prefix<std::ratio<1048576>, U>
::type;
1506 template<
class U>
using gibi =
typename units::detail::prefix<std::ratio<1073741824>, U>
::type;
1507 template<
class U>
using tebi =
typename units::detail::prefix<std::ratio<1099511627776>, U>
::type;
1508 template<
class U>
using pebi =
typename units::detail::prefix<std::ratio<1125899906842624>, U>
::type;
1509 template<
class U>
using exbi =
typename units::detail::prefix<std::ratio<1152921504606846976>, U>
::type;
1530 template<
class U1,
class U2>
1531 struct is_convertible_unit : std::is_same <traits::base_unit_of<typename units::traits::unit_traits<U1>::base_unit_type>,
1532 base_unit_of<typename units::traits::unit_traits<U2>::base_unit_type >> {};
1533 template<
class U1,
class U2>
1546 return y == 0 ? 1.0 : x *
pow(x, y - 1);
1551 return x < 0 ? -x : x;
1555 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1556 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::false_type)
noexcept
1562 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1563 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::true_type)
noexcept
1569 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1570 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::false_type)
noexcept
1576 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1577 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::true_type)
noexcept
1583 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1584 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::false_type)
noexcept
1586 return ((value * Ratio::num) / Ratio::den);
1591 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1592 static inline constexpr
1593 std::enable_if_t<(PiRatio::num / PiRatio::den >= 1 && PiRatio::num % PiRatio::den == 0), T>
1594 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1596 return ((value *
pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1601 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1602 static inline constexpr
1603 std::enable_if_t<(PiRatio::num / PiRatio::den <= -1 && PiRatio::num % PiRatio::den == 0), T>
1604 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1606 return (value * Ratio::num) / (Ratio::den *
pow(constants::detail::PI_VAL, -PiRatio::num / PiRatio::den));
1611 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1613 std::enable_if_t<(PiRatio::num / PiRatio::den < 1 && PiRatio::num / PiRatio::den > -1), T>
1614 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1616 return ((value *
std::pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1620 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1621 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::true_type)
noexcept
1623 return ((value * Ratio::num) / Ratio::den) + (
static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
1627 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1628 static inline constexpr T
convert(
const T& value,
const std::false_type,
const std::true_type,
const std::true_type)
noexcept
1630 return ((value *
std::pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den) + (
static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
1650 template<
class UnitFrom,
class UnitTo,
typename T = UNIT_LIB_DEFAULT_TYPE>
1651 static inline constexpr T
convert(
const T& value)
noexcept
1657 using Ratio = std::ratio_divide<typename UnitFrom::conversion_ratio, typename UnitTo::conversion_ratio>;
1658 using PiRatio = std::ratio_subtract<typename UnitFrom::pi_exponent_ratio, typename UnitTo::pi_exponent_ratio>;
1659 using Translation = std::ratio_divide<std::ratio_subtract<typename UnitFrom::translation_ratio, typename UnitTo::translation_ratio>,
typename UnitTo::conversion_ratio>;
1661 using isSame =
typename std::is_same<std::decay_t<UnitFrom>, std::decay_t<UnitTo>>
::type;
1662 using piRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, PiRatio>::value)>;
1663 using translationRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, Translation>::value)>;
1665 return units::detail::convert<UnitFrom, UnitTo, Ratio, PiRatio, Translation, T>
1666 (value, isSame{}, piRequired{}, translationRequired{});
1682 template<
class T,
class Ret>
1683 struct has_operator_parenthesis_impl
1686 static constexpr auto test(U*) ->
decltype(std::declval<U>()()) {
return decltype(std::declval<U>()()){}; }
1688 static constexpr std::false_type test(...) {
return std::false_type{}; }
1690 using type =
typename std::is_same<Ret, decltype(test<T>(0))>
::type;
1698 template<
class T,
class Ret>
1699 struct has_operator_parenthesis : traits::detail::has_operator_parenthesis_impl<T, Ret>
::type {};
1710 template<
class T,
class Ret>
1711 struct has_value_member_impl
1714 static constexpr auto test(U* p) ->
decltype(p->m_value) {
return p->m_value; }
1716 static constexpr auto test(...)->std::false_type {
return std::false_type{}; }
1718 using type =
typename std::is_same<std::decay_t<Ret>, std::decay_t<decltype(test<T>(0))>>
::type;
1726 template<
class T,
class Ret>
1727 struct has_value_member : traits::detail::has_value_member_impl<T, Ret>
::type {};
1728 template<
class T,
class Ret>
1729 inline constexpr bool has_value_member_v = has_value_member<T, Ret>::value;
1746 template<
class T,
class Ret>
1748 std::is_default_constructible<T>::value &&
1749 has_operator_parenthesis<T, Ret>::value &&
1750 has_value_member<T, Ret>::value &&
1751 std::is_trivial<T>::value>
1761#ifdef FOR_DOXYGEN_PURPOSOES_ONLY
1768 template<
typename T>
1769 struct unit_t_traits
1771 typedef typename T::non_linear_scale_type non_linear_scale_type;
1772 typedef typename T::underlying_type underlying_type;
1773 typedef typename T::value_type value_type;
1774 typedef typename T::unit_type unit_type;
1783 template<
typename T,
typename =
void>
1784 struct unit_t_traits
1786 typedef void non_linear_scale_type;
1787 typedef void underlying_type;
1788 typedef void value_type;
1789 typedef void unit_type;
1797 template<
typename T>
1798 struct unit_t_traits <T, typename
void_t<
1799 typename T::non_linear_scale_type,
1800 typename T::underlying_type,
1801 typename T::value_type,
1802 typename T::unit_type>
::type>
1804 typedef typename T::non_linear_scale_type non_linear_scale_type;
1805 typedef typename T::underlying_type underlying_type;
1806 typedef typename T::value_type value_type;
1807 typedef typename T::unit_type unit_type;
1826 template<
class U1,
class U2>
1828 is_convertible_unit<typename units::traits::unit_t_traits<U1>::unit_type, typename units::traits::unit_t_traits<U2>::unit_type>::value>
1854 #if !defined(_MSC_VER) || _MSC_VER > 1800
1927 template<
class Units,
typename T = UNIT_LIB_DEFAULT_TYPE,
template<
typename>
class NonLinearScale =
linear_scale>
1928 class unit_t :
public NonLinearScale<T>, units::detail::_unit_t
1930 static_assert(
traits::is_unit<Units>::value,
"Template parameter `Units` must be a unit tag. Check that you aren't using a unit type (_t).");
1935 using nls = NonLinearScale<T>;
1959 template<
class... Args>
1970 template<class Ty, class = typename std::enable_if<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>
::type>
1982 inline constexpr unit_t(
const std::chrono::duration<Rep, Period>&
value) noexcept :
1993 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
1995 nls(units::convert<UnitsRhs, Units, T>(rhs.m_value), std::true_type() )
2005 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2008 nls::m_value = units::convert<UnitsRhs, Units, T>(rhs.m_value);
2017 template<class Ty, class = std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>>
2030 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2033 return (nls::m_value < units::convert<UnitsRhs, Units>(rhs.m_value));
2042 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2045 return (nls::m_value <= units::convert<UnitsRhs, Units>(rhs.m_value));
2054 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2057 return (nls::m_value > units::convert<UnitsRhs, Units>(rhs.m_value));
2066 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2069 return (nls::m_value >= units::convert<UnitsRhs, Units>(rhs.m_value));
2079 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs, std::enable_if_t<std::is_floating_point<T>::value || std::is_floating_point<Ty>::value,
int> = 0>
2082 return detail::abs(nls::m_value - units::convert<UnitsRhs, Units>(rhs.m_value)) < std::numeric_limits<T>::epsilon() *
2083 detail::abs(nls::m_value + units::convert<UnitsRhs, Units>(rhs.m_value)) ||
2087 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs, std::enable_if_t<std::is_integral<T>::value && std::is_integral<Ty>::value,
int> = 0>
2090 return nls::m_value == units::convert<UnitsRhs, Units>(rhs.m_value);
2100 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2103 return !(*
this == rhs);
2119 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2120 inline constexpr Ty
to() const noexcept
2122 return static_cast<Ty
>(*this);
2130 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2133 return static_cast<Ty
>(
m_value);
2156 template<class Ty, std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2157 inline constexpr operator Ty() const noexcept
2167 template<class Ty, std::enable_if_t<!traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2168 inline constexpr explicit operator Ty() const noexcept
2170 return static_cast<Ty
>((*this)());
2177 template<
typename U = Units, std::enable_if_t<units::traits::is_convertible_unit<U, unit<std::ratio<1>, category::time_unit>>::value,
int> = 0>
2178 inline constexpr operator std::chrono::nanoseconds() const noexcept
2180 return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::duration<double, std::nano>(
units::convert<Units,
unit<std::ratio<1,1000000000>,
category::time_unit>>((*
this)())));
2186 inline constexpr const char*
name() const noexcept
2201 template<
class U,
typename Ty,
template<
typename>
class Nlt>
2219 template<class UnitType, typename T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
2224 return UnitType(value);
2227#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2228 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2229 inline std::ostream&
operator<<(std::ostream& os,
const unit_t<Units, T, NonLinearScale>& obj)
noexcept
2231 using BaseUnits = unit<std::ratio<1>,
typename traits::unit_traits<Units>::base_unit_type>;
2232 os << convert<Units, BaseUnits>(obj());
2234 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0) { os <<
" m"; }
2235 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0 &&
2236 traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::meter_ratio::num; }
2237 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::meter_ratio::den; }
2239 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0) { os <<
" kg"; }
2240 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0 &&
2241 traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num; }
2242 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den; }
2244 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0) { os <<
" s"; }
2245 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0 &&
2246 traits::unit_traits<Units>::base_unit_type::second_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::second_ratio::num; }
2247 if (traits::unit_traits<Units>::base_unit_type::second_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::second_ratio::den; }
2249 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0) { os <<
" A"; }
2250 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0 &&
2251 traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::num; }
2252 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::den; }
2254 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0) { os <<
" K"; }
2255 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0 &&
2256 traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num; }
2257 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den; }
2259 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0) { os <<
" mol"; }
2260 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0 &&
2261 traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::mole_ratio::num; }
2262 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::mole_ratio::den; }
2264 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0) { os <<
" cd"; }
2265 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0 &&
2266 traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::candela_ratio::num; }
2267 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::candela_ratio::den; }
2269 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0) { os <<
" rad"; }
2270 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0 &&
2271 traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::radian_ratio::num; }
2272 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::radian_ratio::den; }
2274 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0) { os <<
" b"; }
2275 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0 &&
2276 traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::byte_ratio::num; }
2277 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::byte_ratio::den; }
2283 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2288 "parameters are not compatible units.");
2294 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2299 "parameters are not compatible units.");
2305 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2309 "right-hand side parameter must be dimensionless.");
2315 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2319 "right-hand side parameter must be dimensionless.");
2330 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2337 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2345 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2354 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2361 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2369 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2394 template<typename T, typename Units, class = std::enable_if_t<std::is_arithmetic<T>::value && traits::is_unit_t<Units>::value>>
2397 return static_cast<T
>(value);
2405 template<
typename T>
struct decibel_scale;
2416#if !defined(_MSC_VER) || _MSC_VER > 1800
2417 template<
typename... T>
2418 struct has_linear_scale : std::integral_constant<bool, units::all_true<std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T>::underlying_type>, T>::value...>::value > {};
2419 template<
typename... T>
2422 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2424 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2425 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2426 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T3>::underlying_type>, T3>::value> {};
2427 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2438#if !defined(_MSC_VER) || _MSC_VER > 1800
2439 template<
typename... T>
2440 struct has_decibel_scale : std::integral_constant<bool, units::all_true<std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T>::underlying_type>, T>::value...>::value> {};
2441 template<
typename... T>
2444 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2446 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2447 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2448 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T3>::value> {};
2449 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2461 template<
typename T1,
typename T2>
2463 std::is_same<typename units::traits::unit_t_traits<T1>::non_linear_scale_type, typename units::traits::unit_t_traits<T2>::non_linear_scale_type>::value>
2465 template<
typename T1,
typename T2>
2488 template<
typename T>
2495#if defined(_MSC_VER) && (_MSC_VER > 1800)
2499 template<
class... Args>
2521#if defined(_MSC_VER)
2522# pragma warning(push)
2523# pragma warning(disable : 4348)
2527#if defined(_MSC_VER)
2528# pragma warning(pop)
2535 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<!traits::is_same_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2536 constexpr inline int operator+(
const UnitTypeLhs& ,
const UnitTypeRhs& )
noexcept
2543 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2544 inline constexpr UnitTypeLhs
operator+(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2546 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2547 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2548 return UnitTypeLhs(lhs() + convert<UnitsRhs, UnitsLhs>(rhs()));
2552 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2559 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2566 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2567 inline constexpr UnitTypeLhs
operator-(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2569 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2570 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2571 return UnitTypeLhs(lhs() - convert<UnitsRhs, UnitsLhs>(rhs()));
2575 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2582 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2589 template<
class UnitTypeLhs,
class UnitTypeRhs,
2590 std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2593 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2594 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2596 (lhs() * convert<UnitsRhs, UnitsLhs>(rhs()));
2600 template<
class UnitTypeLhs,
class UnitTypeRhs,
2601 std::enable_if_t<!traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2604 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2605 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2606 return unit_t<compound_unit<UnitsLhs, UnitsRhs>>
2611 template<
class UnitTypeLhs,
typename UnitTypeRhs,
2612 std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value && traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2613 inline constexpr UnitTypeLhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2620 template<
class UnitTypeLhs,
typename UnitTypeRhs,
2621 std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && traits::is_dimensionless_unit<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2622 inline constexpr UnitTypeRhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2629 template<
class UnitTypeLhs,
typename T,
2630 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2631 inline constexpr UnitTypeLhs
operator*(
const UnitTypeLhs& lhs, T rhs)
noexcept
2633 return UnitTypeLhs(lhs() * rhs);
2637 template<
class UnitTypeRhs,
typename T,
2638 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2639 inline constexpr UnitTypeRhs
operator*(T lhs,
const UnitTypeRhs& rhs)
noexcept
2641 return UnitTypeRhs(lhs * rhs());
2645 template<
class UnitTypeLhs,
class UnitTypeRhs,
2646 std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2649 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2650 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2655 template<
class UnitTypeLhs,
class UnitTypeRhs,
2656 std::enable_if_t<!traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2659 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2660 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2666 template<
class UnitTypeLhs,
class UnitTypeRhs,
2667 std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value && traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2668 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2674 template<
class UnitTypeLhs,
class UnitTypeRhs,
2675 std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value && traits::is_dimensionless_unit<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2683 template<
class UnitTypeLhs,
typename T,
2684 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2685 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs, T rhs)
noexcept
2687 return UnitTypeLhs(lhs() / rhs);
2691 template<
class UnitTypeRhs,
typename T,
2692 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2695 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2704 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2711 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2718 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2724 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2730 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2736 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2742 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2748 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2754 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2760 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2766 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2769 return lhs < static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs);
2772 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2786 template <
int N,
class U>
struct power_of_unit
2788 typedef typename units::detail::unit_multiply<U,
typename power_of_unit<N - 1, U>
::type>
type;
2792 template <
class U>
struct power_of_unit<1, U>
2808 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2823 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2826 static_assert(power >= 0,
"cpow cannot accept negative numbers. Try units::math::pow instead.");
2842 template<
typename T>
2849#if defined(_MSC_VER) && (_MSC_VER > 1800)
2854 template<
class... Args>
2874#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2877 inline std::ostream&
operator<<(std::ostream& os,
const dB_t& obj) { os << obj() <<
" dB";
return os; }
2881#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
2885 template <
typename FmtContext>
2888 FmtContext& ctx)
const
2890 auto out = ctx.out();
2903 template<
class UnitTypeLhs,
class UnitTypeRhs,
2904 std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2907 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2908 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2909 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2912 (lhs.template toLinearized<underlying_type>() * convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2916 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2919 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2920 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2924 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2927 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type;
2928 return UnitTypeRhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2932 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2935 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2936 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2937 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2940 (lhs.template toLinearized<underlying_type>() / convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2944 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2947 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2948 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2952 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2955 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2956 using underlying_type =
typename units::traits::unit_t_traits<RhsUnits>::underlying_type;
2959 (lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2969 template<
class Units>
2970 struct _unit_value_t {};
2976#ifdef FOR_DOXYGEN_PURPOSES_ONLY
2984 template<
typename T>
2985 struct unit_value_t_traits
2987 typedef typename T::unit_type unit_type;
2988 typedef typename T::ratio ratio;
2997 template<
typename T,
typename =
void>
2998 struct unit_value_t_traits
3000 typedef void unit_type;
3009 template<
typename T>
3010 struct unit_value_t_traits <T, typename
void_t<
3011 typename T::unit_type,
3012 typename T::ratio>
::type>
3014 typedef typename T::unit_type unit_type;
3015 typedef typename T::ratio ratio;
3037 template<
typename Units, std::u
intmax_t Num, std::u
intmax_t Denom = 1>
3057 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3059 std::is_base_of<units::detail::_unit_value_t<Units>, T>::value>
3061 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3069 template<
typename Category,
typename T>
3071 std::is_same<units::traits::base_unit_of<typename traits::unit_value_t_traits<T>::unit_type>, Category>::value>
3075 template<
typename Category,
typename T>
3083 template<
class U1,
class U2>
3084 struct unit_value_arithmetic
3089 using _UNIT1 =
typename traits::unit_value_t_traits<U1>::unit_type;
3090 using _UNIT2 =
typename traits::unit_value_t_traits<U2>::unit_type;
3091 using _CONV1 =
typename units::traits::unit_traits<_UNIT1>::conversion_ratio;
3092 using _CONV2 =
typename units::traits::unit_traits<_UNIT2>::conversion_ratio;
3093 using _RATIO1 =
typename traits::unit_value_t_traits<U1>::ratio;
3094 using _RATIO2 =
typename traits::unit_value_t_traits<U2>::ratio;
3095 using _RATIO2CONV =
typename std::ratio_divide<std::ratio_multiply<_RATIO2, _CONV2>, _CONV1>;
3096 using _PI_EXP = std::ratio_subtract<typename units::traits::unit_traits<_UNIT2>::pi_exponent_ratio,
typename units::traits::unit_traits<_UNIT1>::pi_exponent_ratio>;
3111 template<
class U1,
class U2>
3112 struct unit_value_add : units::detail::unit_value_arithmetic<U1, U2>, units::detail::_unit_value_t<typename traits::unit_value_t_traits<U1>::unit_type>
3115 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3116 typedef typename Base::_UNIT1 unit_type;
3117 using ratio = std::ratio_add<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3130 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3131 return value(UsePi());
3142 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3160 template<
class U1,
class U2>
3161 struct unit_value_subtract : units::detail::unit_value_arithmetic<U1, U2>, units::detail::_unit_value_t<typename traits::unit_value_t_traits<U1>::unit_type>
3164 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3166 typedef typename Base::_UNIT1 unit_type;
3167 using ratio = std::ratio_subtract<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3180 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3181 return value(UsePi());
3192 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3210 template<
class U1,
class U2>
3212 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3213 typename traits::unit_value_t_traits<U2>::unit_type>::value, compound_unit<squared<typename traits::unit_value_t_traits<U1>::unit_type>>,
3214 compound_unit<typename traits::unit_value_t_traits<U1>::unit_type, typename traits::unit_value_t_traits<U2>::unit_type>>::type>
3217 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3220 using ratio = std::conditional_t<traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, std::ratio_multiply<typename Base::_RATIO1, typename Base::_RATIO2CONV>, std::ratio_multiply<typename Base::_RATIO1, typename Base::_RATIO2>>;
3231 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3232 return value(UsePi());
3243 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3260 template<
class U1,
class U2>
3262 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3263 typename traits::unit_value_t_traits<U2>::unit_type>::value, dimensionless::scalar, compound_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3264 inverse<typename traits::unit_value_t_traits<U2>::unit_type>>>::type>
3267 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3270 using ratio = std::conditional_t<traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, std::ratio_divide<typename Base::_RATIO1, typename Base::_RATIO2CONV>, std::ratio_divide<typename Base::_RATIO1, typename Base::_RATIO2>>;
3281 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3282 return value(UsePi());
3293 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3309 template<
class U1,
int power>
3310 struct unit_value_power : units::detail::unit_value_arithmetic<U1, U1>, units::detail::_unit_value_t<typename units::detail::power_of_unit<power, typename traits::unit_value_t_traits<U1>::unit_type>::type>
3313 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3317 using pi_exponent = std::ratio_multiply<std::ratio<power>,
typename Base::_UNIT1::pi_exponent_ratio>;
3328 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3329 return value(UsePi());
3340 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3356 template<
class U1, std::
intmax_t Eps = 10000000000>
3357 struct unit_value_sqrt : units::detail::unit_value_arithmetic<U1, U1>, units::detail::_unit_value_t<square_root<typename traits::unit_value_t_traits<U1>::unit_type, Eps>>
3360 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3375 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3376 return value(UsePi());
3387 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3412 template<
class UnitTypeLhs,
class UnitTypeRhs>
3413 constexpr UnitTypeLhs (
min)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3417 return (lhs < r ? lhs : r);
3420 template<
class UnitTypeLhs,
class UnitTypeRhs>
3421 constexpr UnitTypeLhs (
max)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3425 return (lhs > r ? lhs : r);
3431# if _MSC_VER <= 1800
3432# pragma warning(pop)
3434# pragma pop_macro("constexpr")
3436# pragma pop_macro("noexcept")
3437# undef _ALLOW_KEYWORD_MACROS
3439# pragma pop_macro("pascal")
3442#if defined(UNIT_HAS_LITERAL_SUPPORT)
3447#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
Container for values which represent quantities of a given unit.
Definition: base.h:1929
constexpr bool operator<(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than
Definition: base.h:2031
constexpr bool operator<=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than or equal
Definition: base.h:2043
constexpr unit_t< U > convert() const noexcept
conversion
Definition: base.h:2146
unit_t & operator=(const Ty &rhs) noexcept
assignment
Definition: base.h:2018
constexpr unit_t(const std::chrono::duration< Rep, Period > &value) noexcept
chrono constructor
Definition: base.h:1982
constexpr underlying_type value() const noexcept
unit value
Definition: base.h:2110
constexpr unit_t(const Ty value) noexcept
constructor
Definition: base.h:1971
constexpr unit_t(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
copy constructor (converting)
Definition: base.h:1994
constexpr const char * name() const noexcept
returns the unit name
Definition: base.h:2186
constexpr Ty toLinearized() const noexcept
linearized unit value
Definition: base.h:2131
constexpr Ty to() const noexcept
unit value
Definition: base.h:2120
constexpr bool operator!=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
inequality
Definition: base.h:2101
Units unit_type
Type of unit the unit_t represents (e.g. meters)
Definition: base.h:1943
constexpr bool operator>(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than
Definition: base.h:2055
T value_type
Synonym for underlying type. May be removed in future versions. Prefer underlying_type.
Definition: base.h:1942
constexpr bool operator==(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
equality
Definition: base.h:2080
constexpr unit_t(const T value, const Args &... args) noexcept
constructor
Definition: base.h:1960
constexpr const char * abbreviation() const noexcept
returns the unit abbreviation
Definition: base.h:2194
NonLinearScale< T > non_linear_scale_type
Type of the non-linear scale of the unit_t (e.g. linear_scale)
Definition: base.h:1940
NonLinearScale< T > nls
Definition: base.h:1935
constexpr bool operator>=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than or equal
Definition: base.h:2067
constexpr unit_t()=default
default constructor.
unit_t & operator=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
assignment
Definition: base.h:2006
T underlying_type
Type of the underlying storage of the unit_t (e.g. double)
Definition: base.h:1941
constexpr T unit_cast(const Units &value) noexcept
Casts a unit container to an arithmetic type.
Definition: base.h:2395
static constexpr T convert(const T &value) noexcept
converts a value from one type to another.
Definition: base.h:1651
typename units::detail::Sqrt< Ratio, std::ratio< 1, Eps > >::type ratio_sqrt
Calculate square root of a ratio at compile-time.
Definition: base.h:1359
constexpr UnitType make_unit(const T value) noexcept
Constructs a unit container from an arithmetic type.
Definition: base.h:2220
typename units::detail::prefix< std::peta, U >::type peta
Represents the type of class U with the metric 'peta' prefix appended.
Definition: base.h:1494
typename units::detail::prefix< std::ratio< 1099511627776 >, U >::type tebi
Represents the type of class U with the binary 'tebi' prefix appended.
Definition: base.h:1507
typename units::detail::prefix< std::milli, U >::type milli
Represents the type of class U with the metric 'milli' prefix appended.
Definition: base.h:1485
typename units::detail::inverse_impl< U >::type inverse
represents the inverse unit type of class U.
Definition: base.h:1137
typename units::detail::prefix< std::micro, U >::type micro
Represents the type of class U with the metric 'micro' prefix appended.
Definition: base.h:1484
typename units::detail::prefix< std::ratio< 1048576 >, U >::type mebi
Represents the type of class U with the binary 'mibi' prefix appended.
Definition: base.h:1505
typename units::detail::prefix< std::ratio< 1152921504606846976 >, U >::type exbi
Represents the type of class U with the binary 'exbi' prefix appended.
Definition: base.h:1509
typename units::detail::prefix< std::giga, U >::type giga
Represents the type of class U with the metric 'giga' prefix appended.
Definition: base.h:1492
typename units::detail::squared_impl< U >::type squared
represents the unit type of class U squared
Definition: base.h:1168
typename units::detail::prefix< std::deca, U >::type deca
Represents the type of class U with the metric 'deca' prefix appended.
Definition: base.h:1488
typename units::detail::prefix< std::deci, U >::type deci
Represents the type of class U with the metric 'deci' prefix appended.
Definition: base.h:1487
typename units::detail::cubed_impl< U >::type cubed
represents the type of class U cubed.
Definition: base.h:1198
typename units::detail::prefix< std::femto, U >::type femto
Represents the type of class U with the metric 'femto' prefix appended.
Definition: base.h:1481
typename units::detail::prefix< std::pico, U >::type pico
Represents the type of class U with the metric 'pico' prefix appended.
Definition: base.h:1482
typename units::detail::prefix< std::tera, U >::type tera
Represents the type of class U with the metric 'tera' prefix appended.
Definition: base.h:1493
typename units::detail::prefix< std::hecto, U >::type hecto
Represents the type of class U with the metric 'hecto' prefix appended.
Definition: base.h:1489
typename units::detail::prefix< std::atto, U >::type atto
Represents the type of class U with the metric 'atto' prefix appended.
Definition: base.h:1480
typename units::detail::prefix< std::ratio< 1073741824 >, U >::type gibi
Represents the type of class U with the binary 'gibi' prefix appended.
Definition: base.h:1506
typename units::detail::prefix< std::exa, U >::type exa
Represents the type of class U with the metric 'exa' prefix appended.
Definition: base.h:1495
typename units::detail::sqrt_impl< U, Eps >::type square_root
represents the square root of type class U.
Definition: base.h:1404
typename units::detail::prefix< std::ratio< 1125899906842624 >, U >::type pebi
Represents the type of class U with the binary 'pebi' prefix appended.
Definition: base.h:1508
typename units::detail::prefix< std::ratio< 1024 >, U >::type kibi
Represents the type of class U with the binary 'kibi' prefix appended.
Definition: base.h:1504
typename units::detail::prefix< std::centi, U >::type centi
Represents the type of class U with the metric 'centi' prefix appended.
Definition: base.h:1486
typename units::detail::prefix< std::nano, U >::type nano
Represents the type of class U with the metric 'nano' prefix appended.
Definition: base.h:1483
typename units::detail::prefix< std::mega, U >::type mega
Represents the type of class U with the metric 'mega' prefix appended.
Definition: base.h:1491
typename units::detail::prefix< std::kilo, U >::type kilo
Represents the type of class U with the metric 'kilo' prefix appended.
Definition: base.h:1490
constexpr UnitType abs(const UnitType x) noexcept
Compute absolute value.
Definition: math.h:726
constexpr dimensionless::scalar_t log10(const ScalarUnit x) noexcept
Compute common logarithm.
Definition: math.h:367
typename units::detail::compound_impl< U, Us... >::type compound_unit
Represents a unit type made up from other units.
Definition: base.h:1437
detail namespace with internal helper functions
Definition: chrono.h:321
@ value
the parser finished reading a JSON value
constexpr auto count() -> size_t
Definition: base.h:1279
type
Definition: base.h:646
constexpr common_t< T1, T2 > pow(const T1 base, const T2 exp_term) noexcept
Compile-time power function.
Definition: pow.hpp:82
Implement std::hash so that hash_code can be used in STL containers.
Definition: array.h:89
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > time_unit
Represents an SI base unit of time.
Definition: base.h:800
base_unit< detail::meter_ratio< 0 >, std::ratio< 1 > > mass_unit
Represents an SI base unit of mass.
Definition: base.h:799
base_unit< detail::meter_ratio<-3 >, std::ratio< 1 > > density_unit
Represents an SI derived unit of density.
Definition: base.h:837
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-1 > > magnetic_flux_unit
Represents an SI derived unit of magnetic flux.
Definition: base.h:825
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 >, std::ratio< 1 > > angular_velocity_unit
Represents an SI derived unit of angular velocity.
Definition: base.h:812
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 >, std::ratio< 0 >, std::ratio<-2 > > impedance_unit
Represents an SI derived unit of impedance.
Definition: base.h:823
base_unit< detail::meter_ratio< 1 > > length_unit
Represents an SI base unit of length.
Definition: base.h:798
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > luminous_intensity_unit
Represents an SI base unit of luminous intensity.
Definition: base.h:805
base_unit concentration_unit
Represents a unit of concentration.
Definition: base.h:838
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > energy_unit
Represents an SI derived unit of energy.
Definition: base.h:819
base_unit< detail::meter_ratio< 3 > > volume_unit
Represents an SI derived unit of volume.
Definition: base.h:836
base_unit< detail::meter_ratio<-2 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 2 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > illuminance_unit
Represents an SI derived unit of illuminance.
Definition: base.h:829
base_unit dimensionless_unit
Represents a quantity with no dimension.
Definition: base.h:794
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > data_unit
Represents a unit of data size.
Definition: base.h:839
base_unit< detail::meter_ratio<-1 >, std::ratio< 1 >, std::ratio<-2 > > pressure_unit
Represents an SI derived unit of pressure.
Definition: base.h:817
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-2 > > acceleration_unit
Represents an SI derived unit of acceleration.
Definition: base.h:813
base_unit scalar_unit
Represents a quantity with no dimension.
Definition: base.h:793
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 > > power_unit
Represents an SI derived unit of power.
Definition: base.h:820
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > frequency_unit
Represents an SI derived unit of frequency.
Definition: base.h:810
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > angle_unit
Represents an SI base unit of angle.
Definition: base.h:801
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > current_unit
Represents an SI base unit of current.
Definition: base.h:802
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 1 >, std::ratio< 0 >, std::ratio< 1 > > charge_unit
Represents an SI derived unit of charge.
Definition: base.h:818
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 2 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 > > solid_angle_unit
Represents an SI derived unit of solid angle.
Definition: base.h:809
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > substance_unit
Represents an SI base unit of amount of substance.
Definition: base.h:804
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-3 >, std::ratio< 1 > > angular_jerk_unit
Represents an SI derived unit of angular jerk.
Definition: base.h:815
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 >, std::ratio< 0 >, std::ratio<-1 > > voltage_unit
Represents an SI derived unit of voltage.
Definition: base.h:821
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > radioactivity_unit
Represents an SI derived unit of radioactivity.
Definition: base.h:830
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 2 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > luminous_flux_unit
Represents an SI derived unit of luminous flux.
Definition: base.h:828
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > torque_unit
Represents an SI derived unit of torque.
Definition: base.h:834
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-2 > > inductance_unit
Represents an SI derived unit of inductance.
Definition: base.h:827
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-1 > > velocity_unit
Represents an SI derived unit of velocity.
Definition: base.h:811
base_unit< detail::meter_ratio< 1 >, std::ratio< 1 >, std::ratio<-2 > > force_unit
Represents an SI derived unit of force.
Definition: base.h:816
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-2 >, std::ratio< 1 > > angular_acceleration_unit
Represents an SI derived unit of angular acceleration.
Definition: base.h:814
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > data_transfer_rate_unit
Represents a unit of data transfer rate.
Definition: base.h:840
base_unit< detail::meter_ratio<-2 >, std::ratio<-1 >, std::ratio< 4 >, std::ratio< 0 >, std::ratio< 2 > > capacitance_unit
Represents an SI derived unit of capacitance.
Definition: base.h:822
base_unit< detail::meter_ratio<-2 >, std::ratio<-1 >, std::ratio< 3 >, std::ratio< 0 >, std::ratio< 2 > > conductance_unit
Represents an SI derived unit of conductance.
Definition: base.h:824
base_unit< detail::meter_ratio< 0 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-1 > > magnetic_field_strength_unit
Represents an SI derived unit of magnetic field strength.
Definition: base.h:826
base_unit< detail::meter_ratio< 2 > > area_unit
Represents an SI derived unit of area.
Definition: base.h:835
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > temperature_unit
Represents an SI base unit of temperature.
Definition: base.h:803
static constexpr const unit_t< compound_unit< energy::joules, inverse< temperature::kelvin >, inverse< substance::moles > > > R(8.3144598)
Gas constant.
std::string to_string(const T &t)
Definition: base.h:94
unit_t< scalar, UNIT_LIB_DEFAULT_TYPE, decibel_scale > dB_t
Definition: base.h:2871
unit< std::ratio< 1 >, units::category::dimensionless_unit > dimensionless
Definition: base.h:2514
dB_t dBi_t
Definition: base.h:2872
scalar_t dimensionless_t
Definition: base.h:2517
unit_t< scalar > scalar_t
Definition: base.h:2516
unit< std::ratio< 1 >, units::category::scalar_unit > scalar
Definition: base.h:2513
constexpr UnitTypeLhs() min(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3413
constexpr UnitTypeLhs() max(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3421
constexpr auto cpow(const UnitType &value) noexcept -> unit_t< typename units::detail::power_of_unit< power, typename units::traits::unit_t_traits< UnitType >::unit_type >::type, typename units::traits::unit_t_traits< UnitType >::underlying_type, linear_scale >
computes the value of value raised to the power as a constexpr
Definition: base.h:2824
constexpr auto pow(const UnitType &value) noexcept -> unit_t< typename units::detail::power_of_unit< power, typename units::traits::unit_t_traits< UnitType >::unit_type >::type, typename units::traits::unit_t_traits< UnitType >::underlying_type, linear_scale >
computes the value of value raised to the power
Definition: base.h:2809
constexpr bool has_decibel_scale_v
Definition: base.h:2442
constexpr bool is_convertible_unit_v
Definition: base.h:1534
constexpr bool has_linear_scale_v
Definition: base.h:2420
constexpr bool is_unit_value_t_category_v
Definition: base.h:3076
constexpr bool is_same_scale_v
Definition: base.h:2466
constexpr bool is_unit_v
Definition: base.h:723
constexpr bool is_unit_t_v
Definition: base.h:1869
typename units::detail::base_unit_of_impl< U >::type base_unit_of
Trait which returns the base_unit type that a unit is originally derived from.
Definition: base.h:935
constexpr bool is_ratio_v
Definition: base.h:595
constexpr bool is_unit_value_t_v
Definition: base.h:3062
Unit Conversion Library namespace.
Definition: temperature.h:31
unit_t< Units, T, NonLinearScale > & operator*=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2306
unit_t< Units, T, NonLinearScale > & operator/=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2316
constexpr bool operator!=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2719
unit_t< Units, T, NonLinearScale > & operator+=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2284
constexpr const char * abbreviation(const T &)
constexpr bool operator==(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2705
constexpr dimensionless::scalar_t operator/(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
Division for convertible unit_t types with a linear scale.
Definition: base.h:2647
constexpr const char * name(const T &)
constexpr bool operator<(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2767
unit_t< Units, T, NonLinearScale > & operator++(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2338
unit_t< Units, T, NonLinearScale > & operator-=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2295
constexpr bool operator<=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2755
unit_t< Units, T, NonLinearScale > & operator--(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2362
constexpr bool operator>=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2731
constexpr bool operator>(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2743
constexpr unit_t< Units, T, NonLinearScale > operator-(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2355
constexpr unit_t< Units, T, NonLinearScale > operator+(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2331
constexpr auto operator*(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept -> unit_t< compound_unit< squared< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type > > >
Multiplication type for convertible unit_t types with a linear scale.
Definition: base.h:2591
std::enable_if_t<!std::is_reference_v< OStream > &&std::is_base_of_v< raw_ostream, OStream >, OStream && > operator<<(OStream &&OS, const T &Value)
Call the appropriate insertion operator, given an rvalue reference to a raw_ostream object and return...
Definition: raw_ostream.h:398
Class representing SI base unit types.
Definition: base.h:760
Kilogram kilogram_ratio
Definition: base.h:772
Radian radian_ratio
Definition: base.h:774
Kelvin kelvin_ratio
Definition: base.h:776
Ampere ampere_ratio
Definition: base.h:775
Byte byte_ratio
Definition: base.h:779
Candela candela_ratio
Definition: base.h:778
Second second_ratio
Definition: base.h:773
Meter meter_ratio
Definition: base.h:771
Mole mole_ratio
Definition: base.h:777
unit_t scale for representing decibel values.
Definition: base.h:2844
decibel_scale & operator=(const decibel_scale &)=default
constexpr decibel_scale(const T value) noexcept
Definition: base.h:2853
constexpr decibel_scale(const T value, std::true_type, Args &&...) noexcept
Definition: base.h:2855
constexpr decibel_scale()=default
T m_value
linearized value
Definition: base.h:2858
constexpr T operator()() const noexcept
Definition: base.h:2856
constexpr decibel_scale(const decibel_scale &)=default
unit_t scale which is linear
Definition: base.h:2490
constexpr T operator()() const noexcept
returns value.
Definition: base.h:2501
UNIT_LIB_DEFAULT_TYPE m_value
linearized value.
Definition: base.h:2503
constexpr linear_scale(const linear_scale &)=default
linear_scale & operator=(const linear_scale &)=default
constexpr linear_scale()=default
default constructor.
constexpr linear_scale(const T &value, Args &&...) noexcept
constructor.
Definition: base.h:2500
Trait which tests whether a type is inherited from a decibel scale.
Definition: base.h:2440
Trait which tests whether a type is inherited from a linear scale.
Definition: base.h:2418
Trait which tests if a class is a base_unit type.
Definition: base.h:695
Trait which tests whether two container types derived from unit_t are convertible to each other.
Definition: base.h:1829
Trait which checks whether two units can be converted to each other.
Definition: base.h:1532
Trait which tests that class T meets the requirements for a non-linear scale.
Definition: base.h:1752
Trait that tests whether a type represents a std::ratio.
Definition: base.h:593
Trait which tests whether two types has the same non-linear scale.
Definition: base.h:2464
Traits which tests if a class is a unit
Definition: base.h:1867
Trait which tests whether type T is a unit_value_t with a unit type in the given category.
Definition: base.h:3072
Trait which tests whether a type is a unit_value_t representing the given unit type.
Definition: base.h:3060
Traits which tests if a class is a unit
Definition: base.h:721
adds two unit_value_t types at compile-time
Definition: base.h:3113
static constexpr const unit_t< unit_type > value() noexcept
Value of sum.
Definition: base.h:3128
divides two unit_value_t types at compile-time
Definition: base.h:3265
static constexpr const unit_t< unit_type > value() noexcept
Value of quotient.
Definition: base.h:3279
multiplies two unit_value_t types at compile-time
Definition: base.h:3215
static constexpr const unit_t< unit_type > value() noexcept
Value of product.
Definition: base.h:3229
raises unit_value_to a power at compile-time
Definition: base.h:3311
static constexpr const unit_t< unit_type > value() noexcept
Value of exponentiation.
Definition: base.h:3326
calculates square root of unit_value_t at compile-time
Definition: base.h:3358
static constexpr const unit_t< unit_type > value() noexcept
Value of square root.
Definition: base.h:3373
subtracts two unit_value_t types at compile-time
Definition: base.h:3162
static constexpr const unit_t< unit_type > value() noexcept
Value of difference.
Definition: base.h:3178
Stores a rational unit value as a compile-time constant.
Definition: base.h:3039
Units unit_type
Definition: base.h:3040
std::ratio< Num, Denom > ratio
Definition: base.h:3041
static constexpr const unit_t< Units > value()
Definition: base.h:3044
Type representing an arbitrary unit.
Definition: base.h:887
std::ratio_add< std::ratio_multiply< typename BaseUnit::conversion_ratio, Translation >, typename BaseUnit::translation_ratio > translation_ratio
Definition: base.h:895
std::ratio_multiply< typename BaseUnit::conversion_ratio, Conversion > conversion_ratio
Definition: base.h:893
units::traits::unit_traits< BaseUnit >::base_unit_type base_unit_type
Definition: base.h:892
std::ratio_add< typename BaseUnit::pi_exponent_ratio, PiExponent > pi_exponent_ratio
Definition: base.h:894
#define UNIT_LIB_DEFAULT_TYPE
Definition: base.h:59
#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)
Macro to create the is_category_unit type trait.
Definition: base.h:372
typename std::enable_if< B, T >::type enable_if_t
Definition: base.h:317
FMT_INLINE auto format_to(OutputIt &&out, format_string< T... > fmt, T &&... args) -> remove_cvref_t< OutputIt >
Formats args according to specifications in fmt, writes the result to the output iterator out and ret...
Definition: base.h:2922
void void_t
Definition: base.h:343
auto format(wformat_string< T... > fmt, T &&... args) -> std::wstring
Definition: xchar.h:137