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 FormatContext>\
188 auto format(const units::namespaceName::nameSingular ## _t& obj,\
189 FormatContext& ctx) -> decltype(ctx.out()) \
191 auto out = ctx.out();\
192 out = fmt::formatter<double>::format(obj(), ctx);\
193 return fmt::format_to(out, " " #abbrev);\
198 namespace namespaceName\
200 inline std::string to_string(const nameSingular ## _t& obj)\
202 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
206#if defined(UNIT_LIB_ENABLE_IOSTREAM)
207 #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
208 namespace namespaceName\
210 inline std::ostream& operator<<(std::ostream& os, const nameSingular ## _t& obj) \
212 os << obj() << " "#abbrev; return os; \
214 inline std::string to_string(const nameSingular ## _t& obj)\
216 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
231#define UNIT_ADD_NAME(namespaceName, nameSingular, abbrev)\
232template<> inline constexpr const char* name(const namespaceName::nameSingular ## _t&)\
234 return #nameSingular;\
236template<> inline constexpr const char* abbreviation(const namespaceName::nameSingular ## _t&)\
252#if defined(UNIT_HAS_LITERAL_SUPPORT)
253 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)\
256 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation(long double d)\
258 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
260 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation (unsigned long long d)\
262 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
266 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)
288#define UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, ...)\
289 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
290 UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
291 UNIT_ADD_NAME(namespaceName,nameSingular, abbreviation)\
292 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
293 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
315#define UNIT_ADD_WITH_CUSTOM_TYPE(namespaceName, nameSingular, namePlural, abbreviation, underlyingType, ...)\
316 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
317 UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular,underlyingType)\
318 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
319 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
330#define UNIT_ADD_DECIBEL(namespaceName, nameSingular, abbreviation)\
331 namespace namespaceName\
333 typedef unit_t<nameSingular, UNIT_LIB_DEFAULT_TYPE, units::decibel_scale> abbreviation ## _t; \
335 UNIT_ADD_IO(namespaceName, abbreviation, abbreviation)\
336 UNIT_ADD_LITERALS(namespaceName, abbreviation, abbreviation)
347#define UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
353 template<typename T> struct is_ ## unitCategory ## _unit_impl : std::false_type {};\
354 template<typename C, typename U, typename P, typename T>\
355 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 {};\
356 template<typename U, typename S, template<typename> class N>\
357 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 {};\
362#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)\
365 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> {};\
366 template<typename... T> inline constexpr bool is_ ## unitCategory ## _unit_v = is_ ## unitCategory ## _unit<T...>::value;\
368 template <typename T>\
369 concept unitCategory ## _unit = traits::is_ ## unitCategory ## _unit_v<T>;
371#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)\
372 UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
377 UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)
397#define UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
398 UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
399 UNIT_ADD(namespaceName, femto ## nameSingular, femto ## namePlural, f ## abbreviation, femto<namePlural>)\
400 UNIT_ADD(namespaceName, pico ## nameSingular, pico ## namePlural, p ## abbreviation, pico<namePlural>)\
401 UNIT_ADD(namespaceName, nano ## nameSingular, nano ## namePlural, n ## abbreviation, nano<namePlural>)\
402 UNIT_ADD(namespaceName, micro ## nameSingular, micro ## namePlural, u ## abbreviation, micro<namePlural>)\
403 UNIT_ADD(namespaceName, milli ## nameSingular, milli ## namePlural, m ## abbreviation, milli<namePlural>)\
404 UNIT_ADD(namespaceName, centi ## nameSingular, centi ## namePlural, c ## abbreviation, centi<namePlural>)\
405 UNIT_ADD(namespaceName, deci ## nameSingular, deci ## namePlural, d ## abbreviation, deci<namePlural>)\
406 UNIT_ADD(namespaceName, deca ## nameSingular, deca ## namePlural, da ## abbreviation, deca<namePlural>)\
407 UNIT_ADD(namespaceName, hecto ## nameSingular, hecto ## namePlural, h ## abbreviation, hecto<namePlural>)\
408 UNIT_ADD(namespaceName, kilo ## nameSingular, kilo ## namePlural, k ## abbreviation, kilo<namePlural>)\
409 UNIT_ADD(namespaceName, mega ## nameSingular, mega ## namePlural, M ## abbreviation, mega<namePlural>)\
410 UNIT_ADD(namespaceName, giga ## nameSingular, giga ## namePlural, G ## abbreviation, giga<namePlural>)\
411 UNIT_ADD(namespaceName, tera ## nameSingular, tera ## namePlural, T ## abbreviation, tera<namePlural>)\
412 UNIT_ADD(namespaceName, peta ## nameSingular, peta ## namePlural, P ## abbreviation, peta<namePlural>)\
432#define UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
433 UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
434 UNIT_ADD(namespaceName, kibi ## nameSingular, kibi ## namePlural, Ki ## abbreviation, kibi<namePlural>)\
435 UNIT_ADD(namespaceName, mebi ## nameSingular, mebi ## namePlural, Mi ## abbreviation, mebi<namePlural>)\
436 UNIT_ADD(namespaceName, gibi ## nameSingular, gibi ## namePlural, Gi ## abbreviation, gibi<namePlural>)\
437 UNIT_ADD(namespaceName, tebi ## nameSingular, tebi ## namePlural, Ti ## abbreviation, tebi<namePlural>)\
438 UNIT_ADD(namespaceName, pebi ## nameSingular, pebi ## namePlural, Pi ## abbreviation, pebi<namePlural>)\
439 UNIT_ADD(namespaceName, exbi ## nameSingular, exbi ## namePlural, Ei ## abbreviation, exbi<namePlural>)
518 static constexpr const UNIT_LIB_DEFAULT_TYPE PI_VAL = 3.14159265358979323846264338327950288419716939937510;
540 static constexpr auto test(U*)->std::is_integral<
decltype(U::num)> {
return std::is_integral<
decltype(U::num)>{}; }
542 static constexpr std::false_type test(...) {
return std::false_type{}; }
544 using type =
decltype(test<T>(0));
554 struct has_num : units::detail::has_num_impl<T>
::type {};
563 static constexpr auto test(U*)->std::is_integral<
decltype(U::den)> {
return std::is_integral<
decltype(U::den)>{}; }
565 static constexpr std::false_type test(...) {
return std::false_type{}; }
567 using type =
decltype(test<T>(0));
577 struct has_den : units::detail::has_den_impl<T>
::type {};
612 template<
bool...>
struct bool_pack {};
617 template<
bool... Args>
618 struct all_true : std::is_same<units::bool_pack<true, Args...>, units::bool_pack<Args..., true>> {};
619 template<
bool... Args>
620 inline constexpr bool all_true_t_v = all_true<Args...>::type::value;
628#ifdef FOR_DOXYGEN_PURPOSES_ONLY
639 typedef typename T::base_unit_type base_unit_type;
640 typedef typename T::conversion_ratio conversion_ratio;
641 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
642 typedef typename T::translation_ratio translation_ratio;
649 template<
class T,
typename =
void>
652 typedef void base_unit_type;
653 typedef void conversion_ratio;
654 typedef void pi_exponent_ratio;
655 typedef void translation_ratio;
661 typename T::base_unit_type,
662 typename T::conversion_ratio,
663 typename T::pi_exponent_ratio,
664 typename T::translation_ratio>
::type>
666 typedef typename T::base_unit_type base_unit_type;
667 typedef typename T::conversion_ratio conversion_ratio;
668 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
669 typedef typename T::translation_ratio translation_ratio;
681 struct _base_unit_t {};
694 struct is_base_unit : std::is_base_of<units::detail::_base_unit_t, T> {};
706 template<std::
intmax_t Num, std::
intmax_t Den = 1>
707 using meter_ratio = std::ratio<Num, Den>;
749 template<
class Meter = detail::meter_ratio<0>,
750 class Kilogram = std::ratio<0>,
751 class Second = std::ratio<0>,
752 class Radian = std::ratio<0>,
753 class Ampere = std::ratio<0>,
754 class Kelvin = std::ratio<0>,
755 class Mole = std::ratio<0>,
756 class Candela = std::ratio<0>,
757 class Byte = std::ratio<0>>
760 static_assert(
traits::is_ratio<Meter>::value,
"Template parameter `Meter` must be a `std::ratio` representing the exponent of meters the unit has");
762 static_assert(
traits::is_ratio<Second>::value,
"Template parameter `Second` must be a `std::ratio` representing the exponent of seconds the unit has");
763 static_assert(
traits::is_ratio<Ampere>::value,
"Template parameter `Ampere` must be a `std::ratio` representing the exponent of amperes the unit has");
766 static_assert(
traits::is_ratio<Mole>::value,
"Template parameter `Mole` must be a `std::ratio` representing the exponent of moles the unit has");
767 static_assert(
traits::is_ratio<Radian>::value,
"Template parameter `Radian` must be a `std::ratio` representing the exponent of radians the unit has");
768 static_assert(
traits::is_ratio<Byte>::value,
"Template parameter `Byte` must be a `std::ratio` representing the exponent of bytes the unit has");
828 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;
850 template <
class,
class,
class,
class>
struct unit;
851 template<
class Conversion,
class... Exponents,
class PiExponent,
class Translation>
852 struct unit<Conversion,
base_unit<Exponents...>, PiExponent, Translation> : units::detail::_unit
856 static_assert(
traits::is_ratio<Translation>::value,
"Template parameter `Translation` must be a `std::ratio` representing an additive translation required by the unit conversion.");
884 template<
class Conversion,
class BaseUnit,
class PiExponent = std::ratio<0>,
class Translation = std::ratio<0>>
885 struct unit : units::detail::_unit
891 typedef typename units::traits::unit_traits<BaseUnit>::base_unit_type
base_unit_type;
892 typedef typename std::ratio_multiply<typename BaseUnit::conversion_ratio, Conversion>
conversion_ratio;
893 typedef typename std::ratio_add<typename BaseUnit::pi_exponent_ratio, PiExponent>
pi_exponent_ratio;
894 typedef typename std::ratio_add<std::ratio_multiply<typename BaseUnit::conversion_ratio, Translation>,
typename BaseUnit::translation_ratio>
translation_ratio;
909 template<
class>
struct base_unit_of_impl;
910 template<
class Conversion,
class BaseUnit,
class PiExponent,
class Translation>
911 struct base_unit_of_impl<
unit<Conversion, BaseUnit, PiExponent, Translation>> : base_unit_of_impl<BaseUnit> {};
912 template<
class... Exponents>
913 struct base_unit_of_impl<base_unit<Exponents...>>
915 typedef base_unit<Exponents...>
type;
918 struct base_unit_of_impl<void>
945 template<
class,
class>
struct base_unit_multiply_impl;
946 template<
class... Exponents1,
class... Exponents2>
954 template<
class U1,
class U2>
962 template<
class,
class>
struct base_unit_divide_impl;
963 template<
class... Exponents1,
class... Exponents2>
964 struct base_unit_divide_impl<base_unit<Exponents1...>, base_unit<Exponents2...>> {
965 using type = base_unit<std::ratio_subtract<Exponents1, Exponents2>...>;
971 template<
class U1,
class U2>
979 template<
class>
struct inverse_base_impl;
981 template<
class... Exponents>
982 struct inverse_base_impl<base_unit<Exponents...>> {
983 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<-1>>...>;
997 template<
class U>
struct squared_base_impl;
998 template<
class... Exponents>
999 struct squared_base_impl<base_unit<Exponents...>> {
1000 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<2>>...>;
1014 template<
class U>
struct cubed_base_impl;
1015 template<
class... Exponents>
1016 struct cubed_base_impl<base_unit<Exponents...>> {
1017 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<3>>...>;
1031 template<
class U>
struct sqrt_base_impl;
1032 template<
class... Exponents>
1033 struct sqrt_base_impl<base_unit<Exponents...>> {
1034 using type = base_unit<std::ratio_divide<Exponents, std::ratio<2>>...>;
1048 template<
class U>
struct cbrt_base_impl;
1049 template<
class... Exponents>
1050 struct cbrt_base_impl<base_unit<Exponents...>> {
1051 using type = base_unit<std::ratio_divide<Exponents, std::ratio<3>>...>;
1075 template<
class Unit1,
class Unit2>
1076 struct unit_multiply_impl
1078 using type = unit < std::ratio_multiply<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1079 base_unit_multiply <traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1080 std::ratio_add<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1088 template<
class U1,
class U2>
1097 template<
class Unit1,
class Unit2>
1098 struct unit_divide_impl
1100 using type = unit < std::ratio_divide<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1101 base_unit_divide<traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1102 std::ratio_subtract<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1110 template<
class U1,
class U2>
1119 template<
class Unit>
1122 using type = unit < std::ratio<Unit::conversion_ratio::den, Unit::conversion_ratio::num>,
1123 inverse_base<traits::base_unit_of<typename units::traits::unit_traits<Unit>::base_unit_type>>,
1124 std::ratio_multiply<typename units::traits::unit_traits<Unit>::pi_exponent_ratio, std::ratio<-1>>,
1146 template<
class Unit>
1150 using Conversion =
typename Unit::conversion_ratio;
1152 squared_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1153 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1154 typename Unit::translation_ratio
1177 template<
class Unit>
1181 using Conversion =
typename Unit::conversion_ratio;
1183 cubed_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1184 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<3>>,
1185 typename Unit::translation_ratio> ;
1206 using Zero = std::ratio<0>;
1207 using One = std::ratio<1>;
1208 template <
typename R>
using Square = std::ratio_multiply<R, R>;
1211 template <
template <std::
intmax_t N>
class Predicate,
typename enabled =
void>
1212 struct BinarySearch {
1213 template <std::
intmax_t N>
1214 struct SafeDouble_ {
1215 static constexpr const std::intmax_t value = 2 * N;
1216 static_assert(value > 0,
"Overflows when computing 2 * N");
1219 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1 =
void,
typename Condition2 =
void>
1220 struct DoubleSidedSearch_ : DoubleSidedSearch_<Lower, Upper,
1221 std::integral_constant<bool, (Upper - Lower == 1)>,
1222 std::integral_constant<bool, ((Upper - Lower>1 && Predicate<Lower + (Upper - Lower) / 2>::value))>> {};
1224 template <
intmax_t Lower,
intmax_t Upper>
1225 struct DoubleSidedSearch_<Lower, Upper,
std::false_type, std::false_type> : DoubleSidedSearch_<Lower, Lower + (Upper - Lower) / 2> {};
1227 template <
intmax_t Lower,
intmax_t Upper,
typename Condition2>
1228 struct DoubleSidedSearch_<Lower, Upper,
std::true_type, Condition2> : std::integral_constant<intmax_t, Lower>{};
1230 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1>
1231 struct DoubleSidedSearch_<Lower, Upper, Condition1,
std::true_type> : DoubleSidedSearch_<Lower + (Upper - Lower) / 2, Upper>{};
1233 template <std::
intmax_t Lower,
class enabled1 =
void>
1234 struct SingleSidedSearch_ : SingleSidedSearch_<Lower, std::integral_constant<bool, Predicate<SafeDouble_<Lower>::value>::value>>{};
1236 template <std::
intmax_t Lower>
1237 struct SingleSidedSearch_<Lower,
std::false_type> : DoubleSidedSearch_<Lower, SafeDouble_<Lower>::value> {};
1239 template <std::
intmax_t Lower>
1240 struct SingleSidedSearch_<Lower,
std::true_type> : SingleSidedSearch_<SafeDouble_<Lower>::value>{};
1242 static constexpr const std::intmax_t value = SingleSidedSearch_<1>::value;
1245 template <
template <std::
intmax_t N>
class Predicate>
1246 struct BinarySearch<Predicate,
std::
enable_if_t<!Predicate<1>::value>> : std::integral_constant<std::intmax_t, 0>{};
1249 template <
typename R>
1251 template <std::
intmax_t N>
using Predicate_ = std::ratio_less_equal<std::ratio<N>, std::ratio_divide<R, std::ratio<N>>>;
1252 static constexpr const std::intmax_t value = BinarySearch<Predicate_>::value;
1255 template <
typename R>
1256 struct IsPerfectSquare {
1257 static constexpr const std::intmax_t DenSqrt_ = Integer<std::ratio<R::den>>::value;
1258 static constexpr const std::intmax_t NumSqrt_ = Integer<std::ratio<R::num>>::value;
1259 static constexpr const bool value =( DenSqrt_ * DenSqrt_ == R::den && NumSqrt_ * NumSqrt_ == R::num);
1260 using Sqrt = std::ratio<NumSqrt_, DenSqrt_>;
1264 template <
typename Tp,
typename Tq>
1271 template <
typename R>
1273 using P_ =
typename R::P;
1274 using Q_ =
typename R::Q;
1275 using Den_ = std::ratio_subtract<P_, Square<Q_>>;
1276 using A_ = std::ratio_divide<Q_, Den_>;
1277 using B_ = std::ratio_divide<P_, Square<Den_>>;
1278 static constexpr const std::intmax_t I_ = (A_::num + Integer<std::ratio_multiply<B_, Square<std::ratio<A_::den>>>>::value) / A_::den;
1279 using I = std::ratio<I_>;
1280 using Rem = Remainder<B_, std::ratio_subtract<I, A_>>;
1287 template <
typename Tr, std::
intmax_t N>
1288 struct ContinuedFraction {
1289 template <
typename T>
1290 using Abs_ = std::conditional_t<std::ratio_less<T, Zero>::value, std::ratio_subtract<Zero, T>, T>;
1293 using Last_ = ContinuedFraction<
R, N - 1>;
1294 using Reciprocal_ = Reciprocal<typename Last_::Rem>;
1295 using Rem =
typename Reciprocal_::Rem;
1296 using I_ =
typename Reciprocal_::I;
1297 using Den_ = std::ratio_add<typename Last_::W, I_>;
1298 using U = std::ratio_divide<typename Last_::V, Den_>;
1299 using V = std::ratio_divide<std::ratio_add<typename Last_::U, std::ratio_multiply<typename Last_::V, I_>>, Den_>;
1300 using W = std::ratio_divide<One, Den_>;
1301 using Error = Abs_<std::ratio_divide<std::ratio_subtract<U, std::ratio_multiply<V, W>>,
typename Reciprocal<Rem>::I>>;
1304 template <
typename Tr>
1305 struct ContinuedFraction<Tr, 1> {
1308 using V = std::ratio<Integer<R>::value>;
1310 using Rem = Remainder<R, V>;
1311 using Error = std::ratio_divide<One, typename Reciprocal<Rem>::I>;
1314 template <
typename R,
typename Eps, std::
intmax_t N = 1,
typename enabled =
void>
1315 struct Sqrt_ : Sqrt_<R, Eps, N + 1> {};
1317 template <
typename R,
typename Eps, std::
intmax_t N>
1318 struct Sqrt_<
R, Eps, N,
std::
enable_if_t<std::ratio_less_equal<typename ContinuedFraction<R, N>::Error, Eps>::value>> {
1319 using type =
typename ContinuedFraction<R, N>::V;
1322 template <
typename R,
typename Eps,
typename enabled =
void>
1324 static_assert(std::ratio_greater_equal<R, Zero>::value,
"R can't be negative");
1327 template <
typename R,
typename Eps>
1328 struct Sqrt<
R, Eps,
std::
enable_if_t<std::ratio_greater_equal<R, Zero>::value && IsPerfectSquare<R>::value>> {
1329 using type =
typename IsPerfectSquare<R>::Sqrt;
1332 template <
typename R,
typename Eps>
1333 struct Sqrt<
R, Eps,
std::
enable_if_t<(std::ratio_greater_equal<R, Zero>::value && !IsPerfectSquare<R>::value)>> : Sqrt_<R, Eps>{};
1357 template<
typename Ratio, std::
intmax_t Eps = 10000000000>
1368 template<
class Unit, std::
intmax_t Eps>
1372 using Conversion =
typename Unit::conversion_ratio;
1374 sqrt_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1375 std::ratio_divide<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1376 typename Unit::translation_ratio>;
1402 template<
class U, std::
intmax_t Eps = 10000000000>
1417 template<
class U,
class... Us>
struct compound_impl;
1418 template<
class U>
struct compound_impl<U> {
using type = U; };
1419 template<
class U1,
class U2,
class...Us>
1420 struct compound_impl<U1, U2, Us...>
1421 : compound_impl<unit_multiply<U1, U2>, Us...> {};
1435 template<
class U,
class... Us>
1449 template<
class Ratio,
class Unit>
1458 template <
int N,
class U>
1459 struct power_of_ratio
1461 typedef std::ratio_multiply<U,
typename power_of_ratio<N - 1, U>
::type>
type;
1466 struct power_of_ratio<1, U>
1503 template<
class U>
using kibi =
typename units::detail::prefix<std::ratio<1024>, U>
::type;
1504 template<
class U>
using mebi =
typename units::detail::prefix<std::ratio<1048576>, U>
::type;
1505 template<
class U>
using gibi =
typename units::detail::prefix<std::ratio<1073741824>, U>
::type;
1506 template<
class U>
using tebi =
typename units::detail::prefix<std::ratio<1099511627776>, U>
::type;
1507 template<
class U>
using pebi =
typename units::detail::prefix<std::ratio<1125899906842624>, U>
::type;
1508 template<
class U>
using exbi =
typename units::detail::prefix<std::ratio<1152921504606846976>, U>
::type;
1529 template<
class U1,
class U2>
1530 struct is_convertible_unit : std::is_same <traits::base_unit_of<typename units::traits::unit_traits<U1>::base_unit_type>,
1531 base_unit_of<typename units::traits::unit_traits<U2>::base_unit_type >> {};
1532 template<
class U1,
class U2>
1545 return y == 0 ? 1.0 : x *
pow(x, y - 1);
1550 return x < 0 ? -x : x;
1554 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1555 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::false_type)
noexcept
1561 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1562 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::true_type)
noexcept
1568 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1569 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::false_type)
noexcept
1575 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1576 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::true_type)
noexcept
1582 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1583 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::false_type)
noexcept
1585 return ((value * Ratio::num) / Ratio::den);
1590 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1591 static inline constexpr
1592 std::enable_if_t<(PiRatio::num / PiRatio::den >= 1 && PiRatio::num % PiRatio::den == 0), T>
1593 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1595 return ((value *
pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1600 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1601 static inline constexpr
1602 std::enable_if_t<(PiRatio::num / PiRatio::den <= -1 && PiRatio::num % PiRatio::den == 0), T>
1603 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1605 return (value * Ratio::num) / (Ratio::den *
pow(constants::detail::PI_VAL, -PiRatio::num / PiRatio::den));
1610 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1612 std::enable_if_t<(PiRatio::num / PiRatio::den < 1 && PiRatio::num / PiRatio::den > -1), T>
1613 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1615 return ((value *
std::pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1619 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1620 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::true_type)
noexcept
1622 return ((value * Ratio::num) / Ratio::den) + (
static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
1626 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1627 static inline constexpr T
convert(
const T& value,
const std::false_type,
const std::true_type,
const std::true_type)
noexcept
1629 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);
1649 template<
class UnitFrom,
class UnitTo,
typename T = UNIT_LIB_DEFAULT_TYPE>
1650 static inline constexpr T
convert(
const T& value)
noexcept
1656 using Ratio = std::ratio_divide<typename UnitFrom::conversion_ratio, typename UnitTo::conversion_ratio>;
1657 using PiRatio = std::ratio_subtract<typename UnitFrom::pi_exponent_ratio, typename UnitTo::pi_exponent_ratio>;
1658 using Translation = std::ratio_divide<std::ratio_subtract<typename UnitFrom::translation_ratio, typename UnitTo::translation_ratio>,
typename UnitTo::conversion_ratio>;
1660 using isSame =
typename std::is_same<std::decay_t<UnitFrom>, std::decay_t<UnitTo>>
::type;
1661 using piRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, PiRatio>::value)>;
1662 using translationRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, Translation>::value)>;
1664 return units::detail::convert<UnitFrom, UnitTo, Ratio, PiRatio, Translation, T>
1665 (value, isSame{}, piRequired{}, translationRequired{});
1681 template<
class T,
class Ret>
1682 struct has_operator_parenthesis_impl
1685 static constexpr auto test(U*) ->
decltype(std::declval<U>()()) {
return decltype(std::declval<U>()()){}; }
1687 static constexpr std::false_type test(...) {
return std::false_type{}; }
1689 using type =
typename std::is_same<Ret, decltype(test<T>(0))>
::type;
1697 template<
class T,
class Ret>
1698 struct has_operator_parenthesis : traits::detail::has_operator_parenthesis_impl<T, Ret>
::type {};
1709 template<
class T,
class Ret>
1710 struct has_value_member_impl
1713 static constexpr auto test(U* p) ->
decltype(p->m_value) {
return p->m_value; }
1715 static constexpr auto test(...)->std::false_type {
return std::false_type{}; }
1717 using type =
typename std::is_same<std::decay_t<Ret>, std::decay_t<decltype(test<T>(0))>>
::type;
1725 template<
class T,
class Ret>
1726 struct has_value_member : traits::detail::has_value_member_impl<T, Ret>
::type {};
1727 template<
class T,
class Ret>
1728 inline constexpr bool has_value_member_v = has_value_member<T, Ret>::value;
1745 template<
class T,
class Ret>
1747 std::is_default_constructible<T>::value &&
1748 has_operator_parenthesis<T, Ret>::value &&
1749 has_value_member<T, Ret>::value &&
1750 std::is_trivial<T>::value>
1760#ifdef FOR_DOXYGEN_PURPOSOES_ONLY
1767 template<
typename T>
1768 struct unit_t_traits
1770 typedef typename T::non_linear_scale_type non_linear_scale_type;
1771 typedef typename T::underlying_type underlying_type;
1772 typedef typename T::value_type value_type;
1773 typedef typename T::unit_type unit_type;
1782 template<
typename T,
typename =
void>
1783 struct unit_t_traits
1785 typedef void non_linear_scale_type;
1786 typedef void underlying_type;
1787 typedef void value_type;
1788 typedef void unit_type;
1796 template<
typename T>
1797 struct unit_t_traits <T, typename
void_t<
1798 typename T::non_linear_scale_type,
1799 typename T::underlying_type,
1800 typename T::value_type,
1801 typename T::unit_type>
::type>
1803 typedef typename T::non_linear_scale_type non_linear_scale_type;
1804 typedef typename T::underlying_type underlying_type;
1805 typedef typename T::value_type value_type;
1806 typedef typename T::unit_type unit_type;
1825 template<
class U1,
class U2>
1827 is_convertible_unit<typename units::traits::unit_t_traits<U1>::unit_type, typename units::traits::unit_t_traits<U2>::unit_type>::value>
1853 #if !defined(_MSC_VER) || _MSC_VER > 1800
1926 template<
class Units,
typename T = UNIT_LIB_DEFAULT_TYPE,
template<
typename>
class NonLinearScale =
linear_scale>
1927 class unit_t :
public NonLinearScale<T>, units::detail::_unit_t
1929 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).");
1934 using nls = NonLinearScale<T>;
1958 template<
class... Args>
1969 template<class Ty, class = typename std::enable_if<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>
::type>
1981 inline constexpr unit_t(
const std::chrono::duration<Rep, Period>&
value) noexcept :
1992 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
1994 nls(units::convert<UnitsRhs, Units, T>(rhs.m_value), std::true_type() )
2004 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2007 nls::m_value = units::convert<UnitsRhs, Units, T>(rhs.m_value);
2016 template<class Ty, class = std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>>
2029 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2032 return (nls::m_value < units::convert<UnitsRhs, Units>(rhs.m_value));
2041 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2044 return (nls::m_value <= units::convert<UnitsRhs, Units>(rhs.m_value));
2053 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2056 return (nls::m_value > units::convert<UnitsRhs, Units>(rhs.m_value));
2065 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2068 return (nls::m_value >= units::convert<UnitsRhs, Units>(rhs.m_value));
2078 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>
2081 return detail::abs(nls::m_value - units::convert<UnitsRhs, Units>(rhs.m_value)) < std::numeric_limits<T>::epsilon() *
2082 detail::abs(nls::m_value + units::convert<UnitsRhs, Units>(rhs.m_value)) ||
2086 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>
2089 return nls::m_value == units::convert<UnitsRhs, Units>(rhs.m_value);
2099 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2102 return !(*
this == rhs);
2118 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2119 inline constexpr Ty
to() const noexcept
2121 return static_cast<Ty
>(*this);
2129 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2132 return static_cast<Ty
>(
m_value);
2155 template<class Ty, std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2156 inline constexpr operator Ty() const noexcept
2166 template<class Ty, std::enable_if_t<!traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2167 inline constexpr explicit operator Ty() const noexcept
2169 return static_cast<Ty
>((*this)());
2176 template<
typename U = Units, std::enable_if_t<units::traits::is_convertible_unit<U, unit<std::ratio<1>, category::time_unit>>::value,
int> = 0>
2177 inline constexpr operator std::chrono::nanoseconds() const noexcept
2179 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)())));
2185 inline constexpr const char*
name() const noexcept
2200 template<
class U,
typename Ty,
template<
typename>
class Nlt>
2218 template<class UnitType, typename T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
2223 return UnitType(value);
2226#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2227 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2228 inline std::ostream&
operator<<(std::ostream& os,
const unit_t<Units, T, NonLinearScale>& obj)
noexcept
2230 using BaseUnits = unit<std::ratio<1>,
typename traits::unit_traits<Units>::base_unit_type>;
2231 os << convert<Units, BaseUnits>(obj());
2233 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0) { os <<
" m"; }
2234 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0 &&
2235 traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::meter_ratio::num; }
2236 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::meter_ratio::den; }
2238 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0) { os <<
" kg"; }
2239 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0 &&
2240 traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num; }
2241 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den; }
2243 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0) { os <<
" s"; }
2244 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0 &&
2245 traits::unit_traits<Units>::base_unit_type::second_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::second_ratio::num; }
2246 if (traits::unit_traits<Units>::base_unit_type::second_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::second_ratio::den; }
2248 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0) { os <<
" A"; }
2249 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0 &&
2250 traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::num; }
2251 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::den; }
2253 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0) { os <<
" K"; }
2254 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0 &&
2255 traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num; }
2256 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den; }
2258 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0) { os <<
" mol"; }
2259 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0 &&
2260 traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::mole_ratio::num; }
2261 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::mole_ratio::den; }
2263 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0) { os <<
" cd"; }
2264 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0 &&
2265 traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::candela_ratio::num; }
2266 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::candela_ratio::den; }
2268 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0) { os <<
" rad"; }
2269 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0 &&
2270 traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::radian_ratio::num; }
2271 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::radian_ratio::den; }
2273 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0) { os <<
" b"; }
2274 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0 &&
2275 traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::byte_ratio::num; }
2276 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::byte_ratio::den; }
2282 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2287 "parameters are not compatible units.");
2293 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2298 "parameters are not compatible units.");
2304 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2308 "right-hand side parameter must be dimensionless.");
2314 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2318 "right-hand side parameter must be dimensionless.");
2329 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2336 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2344 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2353 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2360 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2368 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2393 template<typename T, typename Units, class = std::enable_if_t<std::is_arithmetic<T>::value && traits::is_unit_t<Units>::value>>
2396 return static_cast<T
>(value);
2404 template<
typename T>
struct decibel_scale;
2415#if !defined(_MSC_VER) || _MSC_VER > 1800
2416 template<
typename... T>
2417 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 > {};
2418 template<
typename... T>
2421 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2423 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2424 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2425 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T3>::underlying_type>, T3>::value> {};
2426 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2437#if !defined(_MSC_VER) || _MSC_VER > 1800
2438 template<
typename... T>
2439 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> {};
2440 template<
typename... T>
2443 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2445 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2446 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2447 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T3>::value> {};
2448 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2460 template<
typename T1,
typename T2>
2462 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>
2464 template<
typename T1,
typename T2>
2487 template<
typename T>
2494#if defined(_MSC_VER) && (_MSC_VER > 1800)
2498 template<
class... Args>
2520#if defined(_MSC_VER)
2521# pragma warning(push)
2522# pragma warning(disable : 4348)
2526#if defined(_MSC_VER)
2527# pragma warning(pop)
2534 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<!traits::is_same_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2535 constexpr inline int operator+(
const UnitTypeLhs& ,
const UnitTypeRhs& )
noexcept
2542 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2543 inline constexpr UnitTypeLhs
operator+(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2545 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2546 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2547 return UnitTypeLhs(lhs() + convert<UnitsRhs, UnitsLhs>(rhs()));
2551 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2558 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2565 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2566 inline constexpr UnitTypeLhs
operator-(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2568 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2569 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2570 return UnitTypeLhs(lhs() - convert<UnitsRhs, UnitsLhs>(rhs()));
2574 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2581 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2588 template<
class UnitTypeLhs,
class UnitTypeRhs,
2589 std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2592 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2593 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2595 (lhs() * convert<UnitsRhs, UnitsLhs>(rhs()));
2599 template<
class UnitTypeLhs,
class UnitTypeRhs,
2600 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>
2603 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2604 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2605 return unit_t<compound_unit<UnitsLhs, UnitsRhs>>
2610 template<
class UnitTypeLhs,
typename UnitTypeRhs,
2611 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>
2612 inline constexpr UnitTypeLhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2619 template<
class UnitTypeLhs,
typename UnitTypeRhs,
2620 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>
2621 inline constexpr UnitTypeRhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2628 template<
class UnitTypeLhs,
typename T,
2629 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2630 inline constexpr UnitTypeLhs
operator*(
const UnitTypeLhs& lhs, T rhs)
noexcept
2632 return UnitTypeLhs(lhs() * rhs);
2636 template<
class UnitTypeRhs,
typename T,
2637 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2638 inline constexpr UnitTypeRhs
operator*(T lhs,
const UnitTypeRhs& rhs)
noexcept
2640 return UnitTypeRhs(lhs * rhs());
2644 template<
class UnitTypeLhs,
class UnitTypeRhs,
2645 std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2648 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2649 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2654 template<
class UnitTypeLhs,
class UnitTypeRhs,
2655 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>
2658 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2659 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2665 template<
class UnitTypeLhs,
class UnitTypeRhs,
2666 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>
2667 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2673 template<
class UnitTypeLhs,
class UnitTypeRhs,
2674 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>
2682 template<
class UnitTypeLhs,
typename T,
2683 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2684 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs, T rhs)
noexcept
2686 return UnitTypeLhs(lhs() / rhs);
2690 template<
class UnitTypeRhs,
typename T,
2691 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2694 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2703 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2710 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2717 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2723 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2729 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2735 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2741 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2747 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2753 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2759 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2765 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2768 return lhs < static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs);
2771 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2785 template <
int N,
class U>
struct power_of_unit
2787 typedef typename units::detail::unit_multiply<U,
typename power_of_unit<N - 1, U>
::type>
type;
2791 template <
class U>
struct power_of_unit<1, U>
2807 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2822 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2825 static_assert(power >= 0,
"cpow cannot accept negative numbers. Try units::math::pow instead.");
2841 template<
typename T>
2848#if defined(_MSC_VER) && (_MSC_VER > 1800)
2853 template<
class... Args>
2873#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2876 inline std::ostream&
operator<<(std::ostream& os,
const dB_t& obj) { os << obj() <<
" dB";
return os; }
2880#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
2884 template <
typename FormatContext>
2886 FormatContext& ctx) ->
decltype(ctx.out())
2888 auto out = ctx.out();
2901 template<
class UnitTypeLhs,
class UnitTypeRhs,
2902 std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2905 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2906 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2907 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2910 (lhs.template toLinearized<underlying_type>() * convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2914 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2917 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2918 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2922 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2925 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type;
2926 return UnitTypeRhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2930 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2933 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2934 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2935 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2938 (lhs.template toLinearized<underlying_type>() / convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2942 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2945 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2946 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2950 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2953 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2954 using underlying_type =
typename units::traits::unit_t_traits<RhsUnits>::underlying_type;
2957 (lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2967 template<
class Units>
2968 struct _unit_value_t {};
2974#ifdef FOR_DOXYGEN_PURPOSES_ONLY
2982 template<
typename T>
2983 struct unit_value_t_traits
2985 typedef typename T::unit_type unit_type;
2986 typedef typename T::ratio ratio;
2995 template<
typename T,
typename =
void>
2996 struct unit_value_t_traits
2998 typedef void unit_type;
3007 template<
typename T>
3008 struct unit_value_t_traits <T, typename
void_t<
3009 typename T::unit_type,
3010 typename T::ratio>
::type>
3012 typedef typename T::unit_type unit_type;
3013 typedef typename T::ratio ratio;
3035 template<
typename Units, std::u
intmax_t Num, std::u
intmax_t Denom = 1>
3055 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3057 std::is_base_of<units::detail::_unit_value_t<Units>, T>::value>
3059 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3067 template<
typename Category,
typename T>
3069 std::is_same<units::traits::base_unit_of<typename traits::unit_value_t_traits<T>::unit_type>, Category>::value>
3073 template<
typename Category,
typename T>
3081 template<
class U1,
class U2>
3082 struct unit_value_arithmetic
3087 using _UNIT1 =
typename traits::unit_value_t_traits<U1>::unit_type;
3088 using _UNIT2 =
typename traits::unit_value_t_traits<U2>::unit_type;
3089 using _CONV1 =
typename units::traits::unit_traits<_UNIT1>::conversion_ratio;
3090 using _CONV2 =
typename units::traits::unit_traits<_UNIT2>::conversion_ratio;
3091 using _RATIO1 =
typename traits::unit_value_t_traits<U1>::ratio;
3092 using _RATIO2 =
typename traits::unit_value_t_traits<U2>::ratio;
3093 using _RATIO2CONV =
typename std::ratio_divide<std::ratio_multiply<_RATIO2, _CONV2>, _CONV1>;
3094 using _PI_EXP = std::ratio_subtract<typename units::traits::unit_traits<_UNIT2>::pi_exponent_ratio,
typename units::traits::unit_traits<_UNIT1>::pi_exponent_ratio>;
3109 template<
class U1,
class U2>
3110 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>
3113 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3114 typedef typename Base::_UNIT1 unit_type;
3115 using ratio = std::ratio_add<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3128 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3129 return value(UsePi());
3140 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3158 template<
class U1,
class U2>
3159 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>
3162 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3164 typedef typename Base::_UNIT1 unit_type;
3165 using ratio = std::ratio_subtract<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3178 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3179 return value(UsePi());
3190 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3208 template<
class U1,
class U2>
3210 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3211 typename traits::unit_value_t_traits<U2>::unit_type>::value, compound_unit<squared<typename traits::unit_value_t_traits<U1>::unit_type>>,
3212 compound_unit<typename traits::unit_value_t_traits<U1>::unit_type, typename traits::unit_value_t_traits<U2>::unit_type>>::type>
3215 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3218 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>>;
3229 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3230 return value(UsePi());
3241 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3258 template<
class U1,
class U2>
3260 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3261 typename traits::unit_value_t_traits<U2>::unit_type>::value, dimensionless::scalar, compound_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3262 inverse<typename traits::unit_value_t_traits<U2>::unit_type>>>::type>
3265 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3268 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>>;
3279 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3280 return value(UsePi());
3291 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3307 template<
class U1,
int power>
3308 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>
3311 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3315 using pi_exponent = std::ratio_multiply<std::ratio<power>,
typename Base::_UNIT1::pi_exponent_ratio>;
3326 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3327 return value(UsePi());
3338 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3354 template<
class U1, std::
intmax_t Eps = 10000000000>
3355 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>>
3358 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3373 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3374 return value(UsePi());
3385 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3410 template<
class UnitTypeLhs,
class UnitTypeRhs>
3411 UnitTypeLhs (
min)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3415 return (lhs < r ? lhs : r);
3418 template<
class UnitTypeLhs,
class UnitTypeRhs>
3419 UnitTypeLhs (
max)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3423 return (lhs > r ? lhs : r);
3429# if _MSC_VER <= 1800
3430# pragma warning(pop)
3432# pragma pop_macro("constexpr")
3434# pragma pop_macro("noexcept")
3435# undef _ALLOW_KEYWORD_MACROS
3437# pragma pop_macro("pascal")
3440#if defined(UNIT_HAS_LITERAL_SUPPORT)
3445#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
#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:371
Container for values which represent quantities of a given unit.
Definition: base.h:1928
constexpr bool operator<(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than
Definition: base.h:2030
constexpr bool operator<=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than or equal
Definition: base.h:2042
constexpr unit_t< U > convert() const noexcept
conversion
Definition: base.h:2145
unit_t & operator=(const Ty &rhs) noexcept
assignment
Definition: base.h:2017
constexpr unit_t(const std::chrono::duration< Rep, Period > &value) noexcept
chrono constructor
Definition: base.h:1981
constexpr underlying_type value() const noexcept
unit value
Definition: base.h:2109
constexpr unit_t(const Ty value) noexcept
constructor
Definition: base.h:1970
constexpr unit_t(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
copy constructor (converting)
Definition: base.h:1993
constexpr const char * name() const noexcept
returns the unit name
Definition: base.h:2185
constexpr Ty toLinearized() const noexcept
linearized unit value
Definition: base.h:2130
constexpr Ty to() const noexcept
unit value
Definition: base.h:2119
constexpr bool operator!=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
inequality
Definition: base.h:2100
Units unit_type
Type of unit the unit_t represents (e.g. meters)
Definition: base.h:1942
constexpr bool operator>(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than
Definition: base.h:2054
T value_type
Synonym for underlying type. May be removed in future versions. Prefer underlying_type.
Definition: base.h:1941
constexpr bool operator==(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
equality
Definition: base.h:2079
constexpr unit_t(const T value, const Args &... args) noexcept
constructor
Definition: base.h:1959
constexpr const char * abbreviation() const noexcept
returns the unit abbreviation
Definition: base.h:2193
NonLinearScale< T > non_linear_scale_type
Type of the non-linear scale of the unit_t (e.g. linear_scale)
Definition: base.h:1939
NonLinearScale< T > nls
Definition: base.h:1934
constexpr bool operator>=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than or equal
Definition: base.h:2066
constexpr unit_t()=default
default constructor.
unit_t & operator=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
assignment
Definition: base.h:2005
T underlying_type
Type of the underlying storage of the unit_t (e.g. double)
Definition: base.h:1940
typename std::enable_if< B, T >::type enable_if_t
Definition: core.h:271
constexpr T unit_cast(const Units &value) noexcept
Casts a unit container to an arithmetic type.
Definition: base.h:2394
static constexpr T convert(const T &value) noexcept
converts a value from one type to another.
Definition: base.h:1650
typename units::detail::Sqrt< Ratio, std::ratio< 1, Eps > >::type ratio_sqrt
Calculate square root of a ratio at compile-time.
Definition: base.h:1358
constexpr UnitType make_unit(const T value) noexcept
Constructs a unit container from an arithmetic type.
Definition: base.h:2219
typename units::detail::prefix< std::peta, U >::type peta
Represents the type of class U with the metric 'peta' prefix appended.
Definition: base.h:1493
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:1506
typename units::detail::prefix< std::milli, U >::type milli
Represents the type of class U with the metric 'milli' prefix appended.
Definition: base.h:1484
typename units::detail::inverse_impl< U >::type inverse
represents the inverse unit type of class U.
Definition: base.h:1136
typename units::detail::prefix< std::micro, U >::type micro
Represents the type of class U with the metric 'micro' prefix appended.
Definition: base.h:1483
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:1504
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:1508
typename units::detail::prefix< std::giga, U >::type giga
Represents the type of class U with the metric 'giga' prefix appended.
Definition: base.h:1491
typename units::detail::squared_impl< U >::type squared
represents the unit type of class U squared
Definition: base.h:1167
typename units::detail::prefix< std::deca, U >::type deca
Represents the type of class U with the metric 'deca' prefix appended.
Definition: base.h:1487
typename units::detail::prefix< std::deci, U >::type deci
Represents the type of class U with the metric 'deci' prefix appended.
Definition: base.h:1486
typename units::detail::cubed_impl< U >::type cubed
represents the type of class U cubed.
Definition: base.h:1197
typename units::detail::prefix< std::femto, U >::type femto
Represents the type of class U with the metric 'femto' prefix appended.
Definition: base.h:1480
typename units::detail::prefix< std::pico, U >::type pico
Represents the type of class U with the metric 'pico' prefix appended.
Definition: base.h:1481
typename units::detail::prefix< std::tera, U >::type tera
Represents the type of class U with the metric 'tera' prefix appended.
Definition: base.h:1492
typename units::detail::prefix< std::hecto, U >::type hecto
Represents the type of class U with the metric 'hecto' prefix appended.
Definition: base.h:1488
typename units::detail::prefix< std::atto, U >::type atto
Represents the type of class U with the metric 'atto' prefix appended.
Definition: base.h:1479
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:1505
typename units::detail::prefix< std::exa, U >::type exa
Represents the type of class U with the metric 'exa' prefix appended.
Definition: base.h:1494
typename units::detail::sqrt_impl< U, Eps >::type square_root
represents the square root of type class U.
Definition: base.h:1403
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:1507
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:1503
typename units::detail::prefix< std::centi, U >::type centi
Represents the type of class U with the metric 'centi' prefix appended.
Definition: base.h:1485
typename units::detail::prefix< std::nano, U >::type nano
Represents the type of class U with the metric 'nano' prefix appended.
Definition: base.h:1482
typename units::detail::prefix< std::mega, U >::type mega
Represents the type of class U with the metric 'mega' prefix appended.
Definition: base.h:1490
typename units::detail::prefix< std::kilo, U >::type kilo
Represents the type of class U with the metric 'kilo' prefix appended.
Definition: base.h:1489
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:1436
detail namespace with internal helper functions
Definition: ostream.h:24
void void_t
Definition: core.h:1534
@ value
the parser finished reading a JSON value
constexpr auto count() -> size_t
Definition: core.h:1222
type
Definition: core.h:573
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:799
base_unit< detail::meter_ratio< 0 >, std::ratio< 1 > > mass_unit
Represents an SI base unit of mass.
Definition: base.h:798
base_unit< detail::meter_ratio<-3 >, std::ratio< 1 > > density_unit
Represents an SI derived unit of density.
Definition: base.h:836
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:824
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:811
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:822
base_unit< detail::meter_ratio< 1 > > length_unit
Represents an SI base unit of length.
Definition: base.h:797
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:804
base_unit concentration_unit
Represents a unit of concentration.
Definition: base.h:837
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > energy_unit
Represents an SI derived unit of energy.
Definition: base.h:818
base_unit< detail::meter_ratio< 3 > > volume_unit
Represents an SI derived unit of volume.
Definition: base.h:835
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:828
base_unit dimensionless_unit
Represents a quantity with no dimension.
Definition: base.h:793
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:838
base_unit< detail::meter_ratio<-1 >, std::ratio< 1 >, std::ratio<-2 > > pressure_unit
Represents an SI derived unit of pressure.
Definition: base.h:816
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-2 > > acceleration_unit
Represents an SI derived unit of acceleration.
Definition: base.h:812
base_unit scalar_unit
Represents a quantity with no dimension.
Definition: base.h:792
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 > > power_unit
Represents an SI derived unit of power.
Definition: base.h:819
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > frequency_unit
Represents an SI derived unit of frequency.
Definition: base.h:809
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:800
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:801
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:817
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:808
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:803
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:814
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:820
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > radioactivity_unit
Represents an SI derived unit of radioactivity.
Definition: base.h:829
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:827
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > torque_unit
Represents an SI derived unit of torque.
Definition: base.h:833
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:826
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-1 > > velocity_unit
Represents an SI derived unit of velocity.
Definition: base.h:810
base_unit< detail::meter_ratio< 1 >, std::ratio< 1 >, std::ratio<-2 > > force_unit
Represents an SI derived unit of force.
Definition: base.h:815
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:813
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:839
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:821
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:823
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:825
base_unit< detail::meter_ratio< 2 > > area_unit
Represents an SI derived unit of area.
Definition: base.h:834
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:802
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:2870
unit< std::ratio< 1 >, units::category::dimensionless_unit > dimensionless
Definition: base.h:2513
dB_t dBi_t
Definition: base.h:2871
scalar_t dimensionless_t
Definition: base.h:2516
unit_t< scalar > scalar_t
Definition: base.h:2515
unit< std::ratio< 1 >, units::category::scalar_unit > scalar
Definition: base.h:2512
UnitTypeLhs() max(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3419
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:2823
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:2808
UnitTypeLhs() min(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3411
constexpr bool has_decibel_scale_v
Definition: base.h:2441
constexpr bool is_convertible_unit_v
Definition: base.h:1533
constexpr bool has_linear_scale_v
Definition: base.h:2419
constexpr bool is_unit_value_t_category_v
Definition: base.h:3074
constexpr bool is_same_scale_v
Definition: base.h:2465
constexpr bool is_unit_v
Definition: base.h:722
constexpr bool is_unit_t_v
Definition: base.h:1868
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:934
constexpr bool is_ratio_v
Definition: base.h:594
constexpr bool is_unit_value_t_v
Definition: base.h:3060
Unit Conversion Library namespace.
Definition: volume.h:32
unit_t< Units, T, NonLinearScale > & operator*=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2305
unit_t< Units, T, NonLinearScale > & operator/=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2315
constexpr bool operator!=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2718
unit_t< Units, T, NonLinearScale > & operator+=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2283
constexpr const char * abbreviation(const T &)
constexpr bool operator==(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2704
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:2646
constexpr const char * name(const T &)
constexpr bool operator<(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2766
unit_t< Units, T, NonLinearScale > & operator++(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2337
unit_t< Units, T, NonLinearScale > & operator-=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2294
constexpr bool operator<=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2754
unit_t< Units, T, NonLinearScale > & operator--(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2361
constexpr bool operator>=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2730
constexpr bool operator>(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2742
constexpr unit_t< Units, T, NonLinearScale > operator-(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2354
constexpr unit_t< Units, T, NonLinearScale > operator+(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2330
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:2590
raw_ostream & operator<<(raw_ostream &OS, sys::TimePoint<> TP)
Class representing SI base unit types.
Definition: base.h:759
Kilogram kilogram_ratio
Definition: base.h:771
Radian radian_ratio
Definition: base.h:773
Kelvin kelvin_ratio
Definition: base.h:775
Ampere ampere_ratio
Definition: base.h:774
Byte byte_ratio
Definition: base.h:778
Candela candela_ratio
Definition: base.h:777
Second second_ratio
Definition: base.h:772
Meter meter_ratio
Definition: base.h:770
Mole mole_ratio
Definition: base.h:776
unit_t scale for representing decibel values.
Definition: base.h:2843
decibel_scale & operator=(const decibel_scale &)=default
constexpr decibel_scale(const T value) noexcept
Definition: base.h:2852
constexpr decibel_scale(const T value, std::true_type, Args &&...) noexcept
Definition: base.h:2854
constexpr decibel_scale()=default
T m_value
linearized value
Definition: base.h:2857
constexpr T operator()() const noexcept
Definition: base.h:2855
constexpr decibel_scale(const decibel_scale &)=default
unit_t scale which is linear
Definition: base.h:2489
constexpr T operator()() const noexcept
returns value.
Definition: base.h:2500
UNIT_LIB_DEFAULT_TYPE m_value
linearized value.
Definition: base.h:2502
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:2499
Trait which tests whether a type is inherited from a decibel scale.
Definition: base.h:2439
Trait which tests whether a type is inherited from a linear scale.
Definition: base.h:2417
Trait which tests if a class is a base_unit type.
Definition: base.h:694
Trait which tests whether two container types derived from unit_t are convertible to each other.
Definition: base.h:1828
Trait which checks whether two units can be converted to each other.
Definition: base.h:1531
Trait which tests that class T meets the requirements for a non-linear scale.
Definition: base.h:1751
Trait that tests whether a type represents a std::ratio.
Definition: base.h:592
Trait which tests whether two types has the same non-linear scale.
Definition: base.h:2463
Traits which tests if a class is a unit
Definition: base.h:1866
Trait which tests whether type T is a unit_value_t with a unit type in the given category.
Definition: base.h:3070
Trait which tests whether a type is a unit_value_t representing the given unit type.
Definition: base.h:3058
Traits which tests if a class is a unit
Definition: base.h:720
adds two unit_value_t types at compile-time
Definition: base.h:3111
static constexpr const unit_t< unit_type > value() noexcept
Value of sum.
Definition: base.h:3126
divides two unit_value_t types at compile-time
Definition: base.h:3263
static constexpr const unit_t< unit_type > value() noexcept
Value of quotient.
Definition: base.h:3277
multiplies two unit_value_t types at compile-time
Definition: base.h:3213
static constexpr const unit_t< unit_type > value() noexcept
Value of product.
Definition: base.h:3227
raises unit_value_to a power at compile-time
Definition: base.h:3309
static constexpr const unit_t< unit_type > value() noexcept
Value of exponentiation.
Definition: base.h:3324
calculates square root of unit_value_t at compile-time
Definition: base.h:3356
static constexpr const unit_t< unit_type > value() noexcept
Value of square root.
Definition: base.h:3371
subtracts two unit_value_t types at compile-time
Definition: base.h:3160
static constexpr const unit_t< unit_type > value() noexcept
Value of difference.
Definition: base.h:3176
Stores a rational unit value as a compile-time constant.
Definition: base.h:3037
Units unit_type
Definition: base.h:3038
std::ratio< Num, Denom > ratio
Definition: base.h:3039
static constexpr const unit_t< Units > value()
Definition: base.h:3042
Type representing an arbitrary unit.
Definition: base.h:886
std::ratio_add< std::ratio_multiply< typename BaseUnit::conversion_ratio, Translation >, typename BaseUnit::translation_ratio > translation_ratio
Definition: base.h:894
std::ratio_multiply< typename BaseUnit::conversion_ratio, Conversion > conversion_ratio
Definition: base.h:892
units::traits::unit_traits< BaseUnit >::base_unit_type base_unit_type
Definition: base.h:891
std::ratio_add< typename BaseUnit::pi_exponent_ratio, PiExponent > pi_exponent_ratio
Definition: base.h:893