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
56# define UNIT_HAS_VARIADIC_TEMPLATE_SUPPORT
59#ifndef UNIT_LIB_DEFAULT_TYPE
60# define UNIT_LIB_DEFAULT_TYPE double
74#if defined(UNIT_LIB_ENABLE_IOSTREAM)
79#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
93 template <
typename T> std::string
to_string(
const T& t)
101 char decimalPoint = *lc->decimal_point;
102 if (str.find_last_not_of(
'0') == str.find(decimalPoint)) { offset = 0; }
103 str.erase(str.find_last_not_of(
'0') + offset, std::string::npos);
111 template<
typename T>
inline constexpr const char*
name(
const T&);
112 template<
typename T>
inline constexpr const char*
abbreviation(
const T&);
135#define UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, ...)\
136 namespace namespaceName\
138 typedef __VA_ARGS__ namePlural; \
139 typedef namePlural nameSingular; \
140 typedef namePlural abbreviation; \
150#define UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
151 namespace namespaceName\
153 typedef unit_t<nameSingular> nameSingular ## _t; \
164#define UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular, underlyingType)\
165 namespace namespaceName\
167 typedef unit_t<nameSingular,underlyingType> nameSingular ## _t; \
179#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
180 #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
183 struct fmt::formatter<units::namespaceName::nameSingular ## _t> \
184 : fmt::formatter<double> \
186 template <typename FormatContext>\
187 auto format(const units::namespaceName::nameSingular ## _t& obj,\
188 FormatContext& ctx) -> decltype(ctx.out()) \
190 auto out = ctx.out();\
191 out = fmt::formatter<double>::format(obj(), ctx);\
192 return fmt::format_to(out, " " #abbrev);\
197 namespace namespaceName\
199 inline std::string to_string(const nameSingular ## _t& obj)\
201 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
205#if defined(UNIT_LIB_ENABLE_IOSTREAM)
206 #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
207 namespace namespaceName\
209 inline std::ostream& operator<<(std::ostream& os, const nameSingular ## _t& obj) \
211 os << obj() << " "#abbrev; return os; \
213 inline std::string to_string(const nameSingular ## _t& obj)\
215 return units::detail::to_string(obj()) + std::string(" "#abbrev);\
230#define UNIT_ADD_NAME(namespaceName, nameSingular, abbrev)\
231template<> inline constexpr const char* name(const namespaceName::nameSingular ## _t&)\
233 return #nameSingular;\
235template<> inline constexpr const char* abbreviation(const namespaceName::nameSingular ## _t&)\
251#if defined(UNIT_HAS_LITERAL_SUPPORT)
252 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)\
255 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation(long double d)\
257 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
259 inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation (unsigned long long d)\
261 return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
265 #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)
287#define UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, ...)\
288 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
289 UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
290 UNIT_ADD_NAME(namespaceName,nameSingular, abbreviation)\
291 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
292 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
314#define UNIT_ADD_WITH_CUSTOM_TYPE(namespaceName, nameSingular, namePlural, abbreviation, underlyingType, ...)\
315 UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
316 UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular,underlyingType)\
317 UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
318 UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)
329#define UNIT_ADD_DECIBEL(namespaceName, nameSingular, abbreviation)\
330 namespace namespaceName\
332 typedef unit_t<nameSingular, UNIT_LIB_DEFAULT_TYPE, units::decibel_scale> abbreviation ## _t; \
334 UNIT_ADD_IO(namespaceName, abbreviation, abbreviation)\
335 UNIT_ADD_LITERALS(namespaceName, abbreviation, abbreviation)
346#define UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
352 template<typename T> struct is_ ## unitCategory ## _unit_impl : std::false_type {};\
353 template<typename C, typename U, typename P, typename T>\
354 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 {};\
355 template<typename U, typename S, template<typename> class N>\
356 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 {};\
361#if defined(UNIT_HAS_VARIADIC_TEMPLATE_SUPPORT)
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;\
369#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)\
372 template<typename T1, typename T2 = T1, typename T3 = T1>\
373 struct is_ ## unitCategory ## _unit : std::integral_constant<bool, units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T1>::type>::value &&\
374 units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T2>::type>::value &&\
375 units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T3>::type>::value>{};\
376 template<typename T1, typename T2 = T1, typename T3 = T1>\
377 inline constexpr bool is_ ## unitCategory ## _unit_v = is_ ## unitCategory ## _unit<T1, T2, T3>::value;\
381#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)\
382 UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
387 UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)
407#define UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
408 UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
409 UNIT_ADD(namespaceName, femto ## nameSingular, femto ## namePlural, f ## abbreviation, femto<namePlural>)\
410 UNIT_ADD(namespaceName, pico ## nameSingular, pico ## namePlural, p ## abbreviation, pico<namePlural>)\
411 UNIT_ADD(namespaceName, nano ## nameSingular, nano ## namePlural, n ## abbreviation, nano<namePlural>)\
412 UNIT_ADD(namespaceName, micro ## nameSingular, micro ## namePlural, u ## abbreviation, micro<namePlural>)\
413 UNIT_ADD(namespaceName, milli ## nameSingular, milli ## namePlural, m ## abbreviation, milli<namePlural>)\
414 UNIT_ADD(namespaceName, centi ## nameSingular, centi ## namePlural, c ## abbreviation, centi<namePlural>)\
415 UNIT_ADD(namespaceName, deci ## nameSingular, deci ## namePlural, d ## abbreviation, deci<namePlural>)\
416 UNIT_ADD(namespaceName, deca ## nameSingular, deca ## namePlural, da ## abbreviation, deca<namePlural>)\
417 UNIT_ADD(namespaceName, hecto ## nameSingular, hecto ## namePlural, h ## abbreviation, hecto<namePlural>)\
418 UNIT_ADD(namespaceName, kilo ## nameSingular, kilo ## namePlural, k ## abbreviation, kilo<namePlural>)\
419 UNIT_ADD(namespaceName, mega ## nameSingular, mega ## namePlural, M ## abbreviation, mega<namePlural>)\
420 UNIT_ADD(namespaceName, giga ## nameSingular, giga ## namePlural, G ## abbreviation, giga<namePlural>)\
421 UNIT_ADD(namespaceName, tera ## nameSingular, tera ## namePlural, T ## abbreviation, tera<namePlural>)\
422 UNIT_ADD(namespaceName, peta ## nameSingular, peta ## namePlural, P ## abbreviation, peta<namePlural>)\
442#define UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)\
443 UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
444 UNIT_ADD(namespaceName, kibi ## nameSingular, kibi ## namePlural, Ki ## abbreviation, kibi<namePlural>)\
445 UNIT_ADD(namespaceName, mebi ## nameSingular, mebi ## namePlural, Mi ## abbreviation, mebi<namePlural>)\
446 UNIT_ADD(namespaceName, gibi ## nameSingular, gibi ## namePlural, Gi ## abbreviation, gibi<namePlural>)\
447 UNIT_ADD(namespaceName, tebi ## nameSingular, tebi ## namePlural, Ti ## abbreviation, tebi<namePlural>)\
448 UNIT_ADD(namespaceName, pebi ## nameSingular, pebi ## namePlural, Pi ## abbreviation, pebi<namePlural>)\
449 UNIT_ADD(namespaceName, exbi ## nameSingular, exbi ## namePlural, Ei ## abbreviation, exbi<namePlural>)
528 static constexpr const UNIT_LIB_DEFAULT_TYPE PI_VAL = 3.14159265358979323846264338327950288419716939937510;
550 static constexpr auto test(U*)->std::is_integral<
decltype(U::num)> {
return std::is_integral<
decltype(U::num)>{}; }
552 static constexpr std::false_type test(...) {
return std::false_type{}; }
554 using type =
decltype(test<T>(0));
564 struct has_num : units::detail::has_num_impl<T>
::type {};
573 static constexpr auto test(U*)->std::is_integral<
decltype(U::den)> {
return std::is_integral<
decltype(U::den)>{}; }
575 static constexpr std::false_type test(...) {
return std::false_type{}; }
577 using type =
decltype(test<T>(0));
587 struct has_den : units::detail::has_den_impl<T>
::type {};
622 template<
bool...>
struct bool_pack {};
627 template<
bool... Args>
628 struct all_true : std::is_same<units::bool_pack<true, Args...>, units::bool_pack<Args..., true>> {};
629 template<
bool... Args>
630 inline constexpr bool all_true_t_v = all_true<Args...>::type::value;
638#ifdef FOR_DOXYGEN_PURPOSES_ONLY
649 typedef typename T::base_unit_type base_unit_type;
650 typedef typename T::conversion_ratio conversion_ratio;
651 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
652 typedef typename T::translation_ratio translation_ratio;
659 template<
class T,
typename =
void>
662 typedef void base_unit_type;
663 typedef void conversion_ratio;
664 typedef void pi_exponent_ratio;
665 typedef void translation_ratio;
671 typename T::base_unit_type,
672 typename T::conversion_ratio,
673 typename T::pi_exponent_ratio,
674 typename T::translation_ratio>
::type>
676 typedef typename T::base_unit_type base_unit_type;
677 typedef typename T::conversion_ratio conversion_ratio;
678 typedef typename T::pi_exponent_ratio pi_exponent_ratio;
679 typedef typename T::translation_ratio translation_ratio;
691 struct _base_unit_t {};
704 struct is_base_unit : std::is_base_of<units::detail::_base_unit_t, T> {};
716 template<std::
intmax_t Num, std::
intmax_t Den = 1>
717 using meter_ratio = std::ratio<Num, Den>;
759 template<
class Meter = detail::meter_ratio<0>,
760 class Kilogram = std::ratio<0>,
761 class Second = std::ratio<0>,
762 class Radian = std::ratio<0>,
763 class Ampere = std::ratio<0>,
764 class Kelvin = std::ratio<0>,
765 class Mole = std::ratio<0>,
766 class Candela = std::ratio<0>,
767 class Byte = std::ratio<0>>
770 static_assert(
traits::is_ratio<Meter>::value,
"Template parameter `Meter` must be a `std::ratio` representing the exponent of meters the unit has");
772 static_assert(
traits::is_ratio<Second>::value,
"Template parameter `Second` must be a `std::ratio` representing the exponent of seconds the unit has");
773 static_assert(
traits::is_ratio<Ampere>::value,
"Template parameter `Ampere` must be a `std::ratio` representing the exponent of amperes the unit has");
776 static_assert(
traits::is_ratio<Mole>::value,
"Template parameter `Mole` must be a `std::ratio` representing the exponent of moles the unit has");
777 static_assert(
traits::is_ratio<Radian>::value,
"Template parameter `Radian` must be a `std::ratio` representing the exponent of radians the unit has");
778 static_assert(
traits::is_ratio<Byte>::value,
"Template parameter `Byte` must be a `std::ratio` representing the exponent of bytes the unit has");
838 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;
860 template <
class,
class,
class,
class>
struct unit;
861 template<
class Conversion,
class... Exponents,
class PiExponent,
class Translation>
862 struct unit<Conversion,
base_unit<Exponents...>, PiExponent, Translation> : units::detail::_unit
866 static_assert(
traits::is_ratio<Translation>::value,
"Template parameter `Translation` must be a `std::ratio` representing an additive translation required by the unit conversion.");
894 template<
class Conversion,
class BaseUnit,
class PiExponent = std::ratio<0>,
class Translation = std::ratio<0>>
895 struct unit : units::detail::_unit
901 typedef typename units::traits::unit_traits<BaseUnit>::base_unit_type
base_unit_type;
902 typedef typename std::ratio_multiply<typename BaseUnit::conversion_ratio, Conversion>
conversion_ratio;
903 typedef typename std::ratio_add<typename BaseUnit::pi_exponent_ratio, PiExponent>
pi_exponent_ratio;
904 typedef typename std::ratio_add<std::ratio_multiply<typename BaseUnit::conversion_ratio, Translation>,
typename BaseUnit::translation_ratio>
translation_ratio;
919 template<
class>
struct base_unit_of_impl;
920 template<
class Conversion,
class BaseUnit,
class PiExponent,
class Translation>
921 struct base_unit_of_impl<
unit<Conversion, BaseUnit, PiExponent, Translation>> : base_unit_of_impl<BaseUnit> {};
922 template<
class... Exponents>
923 struct base_unit_of_impl<base_unit<Exponents...>>
925 typedef base_unit<Exponents...>
type;
928 struct base_unit_of_impl<void>
955 template<
class,
class>
struct base_unit_multiply_impl;
956 template<
class... Exponents1,
class... Exponents2>
964 template<
class U1,
class U2>
972 template<
class,
class>
struct base_unit_divide_impl;
973 template<
class... Exponents1,
class... Exponents2>
974 struct base_unit_divide_impl<base_unit<Exponents1...>, base_unit<Exponents2...>> {
975 using type = base_unit<std::ratio_subtract<Exponents1, Exponents2>...>;
981 template<
class U1,
class U2>
989 template<
class>
struct inverse_base_impl;
991 template<
class... Exponents>
992 struct inverse_base_impl<base_unit<Exponents...>> {
993 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<-1>>...>;
1007 template<
class U>
struct squared_base_impl;
1008 template<
class... Exponents>
1009 struct squared_base_impl<base_unit<Exponents...>> {
1010 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<2>>...>;
1024 template<
class U>
struct cubed_base_impl;
1025 template<
class... Exponents>
1026 struct cubed_base_impl<base_unit<Exponents...>> {
1027 using type = base_unit<std::ratio_multiply<Exponents, std::ratio<3>>...>;
1041 template<
class U>
struct sqrt_base_impl;
1042 template<
class... Exponents>
1043 struct sqrt_base_impl<base_unit<Exponents...>> {
1044 using type = base_unit<std::ratio_divide<Exponents, std::ratio<2>>...>;
1058 template<
class U>
struct cbrt_base_impl;
1059 template<
class... Exponents>
1060 struct cbrt_base_impl<base_unit<Exponents...>> {
1061 using type = base_unit<std::ratio_divide<Exponents, std::ratio<3>>...>;
1085 template<
class Unit1,
class Unit2>
1086 struct unit_multiply_impl
1088 using type = unit < std::ratio_multiply<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1089 base_unit_multiply <traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1090 std::ratio_add<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1098 template<
class U1,
class U2>
1107 template<
class Unit1,
class Unit2>
1108 struct unit_divide_impl
1110 using type = unit < std::ratio_divide<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
1111 base_unit_divide<traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
1112 std::ratio_subtract<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
1120 template<
class U1,
class U2>
1129 template<
class Unit>
1132 using type = unit < std::ratio<Unit::conversion_ratio::den, Unit::conversion_ratio::num>,
1133 inverse_base<traits::base_unit_of<typename units::traits::unit_traits<Unit>::base_unit_type>>,
1134 std::ratio_multiply<typename units::traits::unit_traits<Unit>::pi_exponent_ratio, std::ratio<-1>>,
1156 template<
class Unit>
1160 using Conversion =
typename Unit::conversion_ratio;
1162 squared_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1163 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1164 typename Unit::translation_ratio
1187 template<
class Unit>
1191 using Conversion =
typename Unit::conversion_ratio;
1193 cubed_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1194 std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<3>>,
1195 typename Unit::translation_ratio> ;
1216 using Zero = std::ratio<0>;
1217 using One = std::ratio<1>;
1218 template <
typename R>
using Square = std::ratio_multiply<R, R>;
1221 template <
template <std::
intmax_t N>
class Predicate,
typename enabled =
void>
1222 struct BinarySearch {
1223 template <std::
intmax_t N>
1224 struct SafeDouble_ {
1225 static constexpr const std::intmax_t value = 2 * N;
1226 static_assert(value > 0,
"Overflows when computing 2 * N");
1229 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1 =
void,
typename Condition2 =
void>
1230 struct DoubleSidedSearch_ : DoubleSidedSearch_<Lower, Upper,
1231 std::integral_constant<bool, (Upper - Lower == 1)>,
1232 std::integral_constant<bool, ((Upper - Lower>1 && Predicate<Lower + (Upper - Lower) / 2>::value))>> {};
1234 template <
intmax_t Lower,
intmax_t Upper>
1235 struct DoubleSidedSearch_<Lower, Upper,
std::false_type, std::false_type> : DoubleSidedSearch_<Lower, Lower + (Upper - Lower) / 2> {};
1237 template <
intmax_t Lower,
intmax_t Upper,
typename Condition2>
1238 struct DoubleSidedSearch_<Lower, Upper,
std::true_type, Condition2> : std::integral_constant<intmax_t, Lower>{};
1240 template <
intmax_t Lower,
intmax_t Upper,
typename Condition1>
1241 struct DoubleSidedSearch_<Lower, Upper, Condition1,
std::true_type> : DoubleSidedSearch_<Lower + (Upper - Lower) / 2, Upper>{};
1243 template <std::
intmax_t Lower,
class enabled1 =
void>
1244 struct SingleSidedSearch_ : SingleSidedSearch_<Lower, std::integral_constant<bool, Predicate<SafeDouble_<Lower>::value>::value>>{};
1246 template <std::
intmax_t Lower>
1247 struct SingleSidedSearch_<Lower,
std::false_type> : DoubleSidedSearch_<Lower, SafeDouble_<Lower>::value> {};
1249 template <std::
intmax_t Lower>
1250 struct SingleSidedSearch_<Lower,
std::true_type> : SingleSidedSearch_<SafeDouble_<Lower>::value>{};
1252 static constexpr const std::intmax_t value = SingleSidedSearch_<1>::value;
1255 template <
template <std::
intmax_t N>
class Predicate>
1256 struct BinarySearch<Predicate,
std::
enable_if_t<!Predicate<1>::value>> : std::integral_constant<std::intmax_t, 0>{};
1259 template <
typename R>
1261 template <std::
intmax_t N>
using Predicate_ = std::ratio_less_equal<std::ratio<N>, std::ratio_divide<R, std::ratio<N>>>;
1262 static constexpr const std::intmax_t value = BinarySearch<Predicate_>::value;
1265 template <
typename R>
1266 struct IsPerfectSquare {
1267 static constexpr const std::intmax_t DenSqrt_ = Integer<std::ratio<R::den>>::value;
1268 static constexpr const std::intmax_t NumSqrt_ = Integer<std::ratio<R::num>>::value;
1269 static constexpr const bool value =( DenSqrt_ * DenSqrt_ == R::den && NumSqrt_ * NumSqrt_ == R::num);
1270 using Sqrt = std::ratio<NumSqrt_, DenSqrt_>;
1274 template <
typename Tp,
typename Tq>
1281 template <
typename R>
1283 using P_ =
typename R::P;
1284 using Q_ =
typename R::Q;
1285 using Den_ = std::ratio_subtract<P_, Square<Q_>>;
1286 using A_ = std::ratio_divide<Q_, Den_>;
1287 using B_ = std::ratio_divide<P_, Square<Den_>>;
1288 static constexpr const std::intmax_t I_ = (A_::num + Integer<std::ratio_multiply<B_, Square<std::ratio<A_::den>>>>::value) / A_::den;
1289 using I = std::ratio<I_>;
1290 using Rem = Remainder<B_, std::ratio_subtract<I, A_>>;
1297 template <
typename Tr, std::
intmax_t N>
1298 struct ContinuedFraction {
1299 template <
typename T>
1300 using Abs_ = std::conditional_t<std::ratio_less<T, Zero>::value, std::ratio_subtract<Zero, T>, T>;
1303 using Last_ = ContinuedFraction<
R, N - 1>;
1304 using Reciprocal_ = Reciprocal<typename Last_::Rem>;
1305 using Rem =
typename Reciprocal_::Rem;
1306 using I_ =
typename Reciprocal_::I;
1307 using Den_ = std::ratio_add<typename Last_::W, I_>;
1308 using U = std::ratio_divide<typename Last_::V, Den_>;
1309 using V = std::ratio_divide<std::ratio_add<typename Last_::U, std::ratio_multiply<typename Last_::V, I_>>, Den_>;
1310 using W = std::ratio_divide<One, Den_>;
1311 using Error = Abs_<std::ratio_divide<std::ratio_subtract<U, std::ratio_multiply<V, W>>,
typename Reciprocal<Rem>::I>>;
1314 template <
typename Tr>
1315 struct ContinuedFraction<Tr, 1> {
1318 using V = std::ratio<Integer<R>::value>;
1320 using Rem = Remainder<R, V>;
1321 using Error = std::ratio_divide<One, typename Reciprocal<Rem>::I>;
1324 template <
typename R,
typename Eps, std::
intmax_t N = 1,
typename enabled =
void>
1325 struct Sqrt_ : Sqrt_<R, Eps, N + 1> {};
1327 template <
typename R,
typename Eps, std::
intmax_t N>
1328 struct Sqrt_<
R, Eps, N,
std::
enable_if_t<std::ratio_less_equal<typename ContinuedFraction<R, N>::Error, Eps>::value>> {
1329 using type =
typename ContinuedFraction<R, N>::V;
1332 template <
typename R,
typename Eps,
typename enabled =
void>
1334 static_assert(std::ratio_greater_equal<R, Zero>::value,
"R can't be negative");
1337 template <
typename R,
typename Eps>
1338 struct Sqrt<
R, Eps,
std::
enable_if_t<std::ratio_greater_equal<R, Zero>::value && IsPerfectSquare<R>::value>> {
1339 using type =
typename IsPerfectSquare<R>::Sqrt;
1342 template <
typename R,
typename Eps>
1343 struct Sqrt<
R, Eps,
std::
enable_if_t<(std::ratio_greater_equal<R, Zero>::value && !IsPerfectSquare<R>::value)>> : Sqrt_<R, Eps>{};
1367 template<
typename Ratio, std::
intmax_t Eps = 10000000000>
1378 template<
class Unit, std::
intmax_t Eps>
1382 using Conversion =
typename Unit::conversion_ratio;
1384 sqrt_base<traits::base_unit_of<typename Unit::base_unit_type>>,
1385 std::ratio_divide<typename Unit::pi_exponent_ratio, std::ratio<2>>,
1386 typename Unit::translation_ratio>;
1412 template<
class U, std::
intmax_t Eps = 10000000000>
1427 template<
class U,
class... Us>
struct compound_impl;
1428 template<
class U>
struct compound_impl<U> {
using type = U; };
1429 template<
class U1,
class U2,
class...Us>
1430 struct compound_impl<U1, U2, Us...>
1431 : compound_impl<unit_multiply<U1, U2>, Us...> {};
1445 template<
class U,
class... Us>
1459 template<
class Ratio,
class Unit>
1468 template <
int N,
class U>
1469 struct power_of_ratio
1471 typedef std::ratio_multiply<U,
typename power_of_ratio<N - 1, U>
::type>
type;
1476 struct power_of_ratio<1, U>
1513 template<
class U>
using kibi =
typename units::detail::prefix<std::ratio<1024>, U>
::type;
1514 template<
class U>
using mebi =
typename units::detail::prefix<std::ratio<1048576>, U>
::type;
1515 template<
class U>
using gibi =
typename units::detail::prefix<std::ratio<1073741824>, U>
::type;
1516 template<
class U>
using tebi =
typename units::detail::prefix<std::ratio<1099511627776>, U>
::type;
1517 template<
class U>
using pebi =
typename units::detail::prefix<std::ratio<1125899906842624>, U>
::type;
1518 template<
class U>
using exbi =
typename units::detail::prefix<std::ratio<1152921504606846976>, U>
::type;
1539 template<
class U1,
class U2>
1540 struct is_convertible_unit : std::is_same <traits::base_unit_of<typename units::traits::unit_traits<U1>::base_unit_type>,
1541 base_unit_of<typename units::traits::unit_traits<U2>::base_unit_type >> {};
1542 template<
class U1,
class U2>
1555 return y == 0 ? 1.0 : x *
pow(x, y - 1);
1560 return x < 0 ? -x : x;
1564 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1565 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::false_type)
noexcept
1571 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1572 static inline constexpr T
convert(
const T& value, std::true_type, std::false_type, std::true_type)
noexcept
1578 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1579 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::false_type)
noexcept
1585 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1586 static inline constexpr T
convert(
const T& value, std::true_type, std::true_type, std::true_type)
noexcept
1592 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1593 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::false_type)
noexcept
1595 return ((value * 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 *
pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1610 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1611 static inline constexpr
1612 std::enable_if_t<(PiRatio::num / PiRatio::den <= -1 && PiRatio::num % PiRatio::den == 0), T>
1613 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1615 return (value * Ratio::num) / (Ratio::den *
pow(constants::detail::PI_VAL, -PiRatio::num / PiRatio::den));
1620 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1622 std::enable_if_t<(PiRatio::num / PiRatio::den < 1 && PiRatio::num / PiRatio::den > -1), T>
1623 convert(
const T& value, std::false_type, std::true_type, std::false_type)
noexcept
1625 return ((value *
std::pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den) * Ratio::num) / Ratio::den);
1629 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1630 static inline constexpr T
convert(
const T& value, std::false_type, std::false_type, std::true_type)
noexcept
1632 return ((value * Ratio::num) / Ratio::den) + (
static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
1636 template<
class UnitFrom,
class UnitTo,
class Ratio,
class PiRatio,
class Translation,
typename T>
1637 static inline constexpr T
convert(
const T& value,
const std::false_type,
const std::true_type,
const std::true_type)
noexcept
1639 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);
1659 template<
class UnitFrom,
class UnitTo,
typename T = UNIT_LIB_DEFAULT_TYPE>
1660 static inline constexpr T
convert(
const T& value)
noexcept
1666 using Ratio = std::ratio_divide<typename UnitFrom::conversion_ratio, typename UnitTo::conversion_ratio>;
1667 using PiRatio = std::ratio_subtract<typename UnitFrom::pi_exponent_ratio, typename UnitTo::pi_exponent_ratio>;
1668 using Translation = std::ratio_divide<std::ratio_subtract<typename UnitFrom::translation_ratio, typename UnitTo::translation_ratio>,
typename UnitTo::conversion_ratio>;
1670 using isSame =
typename std::is_same<std::decay_t<UnitFrom>, std::decay_t<UnitTo>>
::type;
1671 using piRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, PiRatio>::value)>;
1672 using translationRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, Translation>::value)>;
1674 return units::detail::convert<UnitFrom, UnitTo, Ratio, PiRatio, Translation, T>
1675 (value, isSame{}, piRequired{}, translationRequired{});
1691 template<
class T,
class Ret>
1692 struct has_operator_parenthesis_impl
1695 static constexpr auto test(U*) ->
decltype(std::declval<U>()()) {
return decltype(std::declval<U>()()){}; }
1697 static constexpr std::false_type test(...) {
return std::false_type{}; }
1699 using type =
typename std::is_same<Ret, decltype(test<T>(0))>
::type;
1707 template<
class T,
class Ret>
1708 struct has_operator_parenthesis : traits::detail::has_operator_parenthesis_impl<T, Ret>
::type {};
1719 template<
class T,
class Ret>
1720 struct has_value_member_impl
1723 static constexpr auto test(U* p) ->
decltype(p->m_value) {
return p->m_value; }
1725 static constexpr auto test(...)->std::false_type {
return std::false_type{}; }
1727 using type =
typename std::is_same<std::decay_t<Ret>, std::decay_t<decltype(test<T>(0))>>
::type;
1735 template<
class T,
class Ret>
1736 struct has_value_member : traits::detail::has_value_member_impl<T, Ret>
::type {};
1737 template<
class T,
class Ret>
1738 inline constexpr bool has_value_member_v = has_value_member<T, Ret>::value;
1755 template<
class T,
class Ret>
1757 std::is_default_constructible<T>::value &&
1758 has_operator_parenthesis<T, Ret>::value &&
1759 has_value_member<T, Ret>::value &&
1760 std::is_trivial<T>::value>
1770#ifdef FOR_DOXYGEN_PURPOSOES_ONLY
1777 template<
typename T>
1778 struct unit_t_traits
1780 typedef typename T::non_linear_scale_type non_linear_scale_type;
1781 typedef typename T::underlying_type underlying_type;
1782 typedef typename T::value_type value_type;
1783 typedef typename T::unit_type unit_type;
1792 template<
typename T,
typename =
void>
1793 struct unit_t_traits
1795 typedef void non_linear_scale_type;
1796 typedef void underlying_type;
1797 typedef void value_type;
1798 typedef void unit_type;
1806 template<
typename T>
1807 struct unit_t_traits <T, typename
void_t<
1808 typename T::non_linear_scale_type,
1809 typename T::underlying_type,
1810 typename T::value_type,
1811 typename T::unit_type>
::type>
1813 typedef typename T::non_linear_scale_type non_linear_scale_type;
1814 typedef typename T::underlying_type underlying_type;
1815 typedef typename T::value_type value_type;
1816 typedef typename T::unit_type unit_type;
1835 template<
class U1,
class U2>
1837 is_convertible_unit<typename units::traits::unit_t_traits<U1>::unit_type, typename units::traits::unit_t_traits<U2>::unit_type>::value>
1863 #if !defined(_MSC_VER) || _MSC_VER > 1800
1936 template<
class Units,
typename T = UNIT_LIB_DEFAULT_TYPE,
template<
typename>
class NonLinearScale =
linear_scale>
1937 class unit_t :
public NonLinearScale<T>, units::detail::_unit_t
1939 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).");
1944 using nls = NonLinearScale<T>;
1968 template<
class... Args>
1979 template<class Ty, class = typename std::enable_if<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>
::type>
1991 inline constexpr unit_t(
const std::chrono::duration<Rep, Period>&
value) noexcept :
2002 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2004 nls(units::convert<UnitsRhs, Units, T>(rhs.m_value), std::true_type() )
2014 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2017 nls::m_value = units::convert<UnitsRhs, Units, T>(rhs.m_value);
2026 template<class Ty, class = std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>>
2039 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2042 return (nls::m_value < units::convert<UnitsRhs, Units>(rhs.m_value));
2051 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2054 return (nls::m_value <= units::convert<UnitsRhs, Units>(rhs.m_value));
2063 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2066 return (nls::m_value > units::convert<UnitsRhs, Units>(rhs.m_value));
2075 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2078 return (nls::m_value >= units::convert<UnitsRhs, Units>(rhs.m_value));
2088 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>
2091 return detail::abs(nls::m_value - units::convert<UnitsRhs, Units>(rhs.m_value)) < std::numeric_limits<T>::epsilon() *
2092 detail::abs(nls::m_value + units::convert<UnitsRhs, Units>(rhs.m_value)) ||
2096 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>
2099 return nls::m_value == units::convert<UnitsRhs, Units>(rhs.m_value);
2109 template<
class UnitsRhs,
typename Ty,
template<
typename>
class NlsRhs>
2112 return !(*
this == rhs);
2128 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2129 inline constexpr Ty
to() const noexcept
2131 return static_cast<Ty
>(*this);
2139 template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
2142 return static_cast<Ty
>(
m_value);
2165 template<class Ty, std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2166 inline constexpr operator Ty() const noexcept
2176 template<class Ty, std::enable_if_t<!traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value,
int> = 0>
2177 inline constexpr explicit operator Ty() const noexcept
2179 return static_cast<Ty
>((*this)());
2186 template<
typename U = Units, std::enable_if_t<units::traits::is_convertible_unit<U, unit<std::ratio<1>, category::time_unit>>::value,
int> = 0>
2187 inline constexpr operator std::chrono::nanoseconds() const noexcept
2189 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)())));
2195 inline constexpr const char*
name() const noexcept
2210 template<
class U,
typename Ty,
template<
typename>
class Nlt>
2228 template<class UnitType, typename T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
2233 return UnitType(value);
2236#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2237 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2238 inline std::ostream&
operator<<(std::ostream& os,
const unit_t<Units, T, NonLinearScale>& obj)
noexcept
2240 using BaseUnits = unit<std::ratio<1>,
typename traits::unit_traits<Units>::base_unit_type>;
2241 os << convert<Units, BaseUnits>(obj());
2243 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0) { os <<
" m"; }
2244 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0 &&
2245 traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::meter_ratio::num; }
2246 if (traits::unit_traits<Units>::base_unit_type::meter_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::meter_ratio::den; }
2248 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0) { os <<
" kg"; }
2249 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0 &&
2250 traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num; }
2251 if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den; }
2253 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0) { os <<
" s"; }
2254 if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0 &&
2255 traits::unit_traits<Units>::base_unit_type::second_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::second_ratio::num; }
2256 if (traits::unit_traits<Units>::base_unit_type::second_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::second_ratio::den; }
2258 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0) { os <<
" A"; }
2259 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0 &&
2260 traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::num; }
2261 if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::den; }
2263 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0) { os <<
" K"; }
2264 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0 &&
2265 traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num; }
2266 if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den; }
2268 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0) { os <<
" mol"; }
2269 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0 &&
2270 traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::mole_ratio::num; }
2271 if (traits::unit_traits<Units>::base_unit_type::mole_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::mole_ratio::den; }
2273 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0) { os <<
" cd"; }
2274 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0 &&
2275 traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::candela_ratio::num; }
2276 if (traits::unit_traits<Units>::base_unit_type::candela_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::candela_ratio::den; }
2278 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0) { os <<
" rad"; }
2279 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0 &&
2280 traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::radian_ratio::num; }
2281 if (traits::unit_traits<Units>::base_unit_type::radian_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::radian_ratio::den; }
2283 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0) { os <<
" b"; }
2284 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0 &&
2285 traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 1) { os <<
"^" << traits::unit_traits<Units>::base_unit_type::byte_ratio::num; }
2286 if (traits::unit_traits<Units>::base_unit_type::byte_ratio::den != 1) { os <<
"/" << traits::unit_traits<Units>::base_unit_type::byte_ratio::den; }
2292 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2297 "parameters are not compatible units.");
2303 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2308 "parameters are not compatible units.");
2314 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2318 "right-hand side parameter must be dimensionless.");
2324 template<
class Units,
typename T,
template<
typename>
class NonLinearScale,
typename RhsType>
2328 "right-hand side parameter must be dimensionless.");
2339 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2346 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2354 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2363 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2370 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2378 template<
class Units,
typename T,
template<
typename>
class NonLinearScale>
2403 template<typename T, typename Units, class = std::enable_if_t<std::is_arithmetic<T>::value && traits::is_unit_t<Units>::value>>
2406 return static_cast<T
>(value);
2414 template<
typename T>
struct decibel_scale;
2425#if !defined(_MSC_VER) || _MSC_VER > 1800
2426 template<
typename... T>
2427 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 > {};
2428 template<
typename... T>
2431 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2433 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2434 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2435 std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T3>::underlying_type>, T3>::value> {};
2436 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2447#if !defined(_MSC_VER) || _MSC_VER > 1800
2448 template<
typename... T>
2449 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> {};
2450 template<
typename... T>
2453 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2455 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
2456 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
2457 std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T3>::value> {};
2458 template<
typename T1,
typename T2 = T1,
typename T3 = T1>
2470 template<
typename T1,
typename T2>
2472 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>
2474 template<
typename T1,
typename T2>
2497 template<
typename T>
2504#if defined(_MSC_VER) && (_MSC_VER > 1800)
2508 template<
class... Args>
2530#if defined(_MSC_VER)
2531# pragma warning(push)
2532# pragma warning(disable : 4348)
2536#if defined(_MSC_VER)
2537# pragma warning(pop)
2544 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<!traits::is_same_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2545 constexpr inline int operator+(
const UnitTypeLhs& ,
const UnitTypeRhs& )
noexcept
2552 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2553 inline constexpr UnitTypeLhs
operator+(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2555 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2556 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2557 return UnitTypeLhs(lhs() + convert<UnitsRhs, UnitsLhs>(rhs()));
2561 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2568 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2575 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2576 inline constexpr UnitTypeLhs
operator-(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2578 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2579 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2580 return UnitTypeLhs(lhs() - convert<UnitsRhs, UnitsLhs>(rhs()));
2584 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2591 template<typename T, std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
2598 template<
class UnitTypeLhs,
class UnitTypeRhs,
2599 std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2602 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2603 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2605 (lhs() * convert<UnitsRhs, UnitsLhs>(rhs()));
2609 template<
class UnitTypeLhs,
class UnitTypeRhs,
2610 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>
2613 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2614 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2615 return unit_t<compound_unit<UnitsLhs, UnitsRhs>>
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 UnitTypeLhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2629 template<
class UnitTypeLhs,
typename UnitTypeRhs,
2630 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>
2631 inline constexpr UnitTypeRhs
operator*(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2638 template<
class UnitTypeLhs,
typename T,
2639 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2640 inline constexpr UnitTypeLhs
operator*(
const UnitTypeLhs& lhs, T rhs)
noexcept
2642 return UnitTypeLhs(lhs() * rhs);
2646 template<
class UnitTypeRhs,
typename T,
2647 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2648 inline constexpr UnitTypeRhs
operator*(T lhs,
const UnitTypeRhs& rhs)
noexcept
2650 return UnitTypeRhs(lhs * rhs());
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,
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;
2664 template<
class UnitTypeLhs,
class UnitTypeRhs,
2665 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>
2668 using UnitsLhs =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2669 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2675 template<
class UnitTypeLhs,
class UnitTypeRhs,
2676 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>
2677 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
noexcept
2683 template<
class UnitTypeLhs,
class UnitTypeRhs,
2684 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>
2692 template<
class UnitTypeLhs,
typename T,
2693 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value,
int> = 0>
2694 inline constexpr UnitTypeLhs
operator/(
const UnitTypeLhs& lhs, T rhs)
noexcept
2696 return UnitTypeLhs(lhs() / rhs);
2700 template<
class UnitTypeRhs,
typename T,
2701 std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value,
int> = 0>
2704 using UnitsRhs =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2713 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2720 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2727 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2733 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2739 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2745 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2751 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2757 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2763 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2769 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2775 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2778 return lhs < static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs);
2781 template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
2795 template <
int N,
class U>
struct power_of_unit
2797 typedef typename units::detail::unit_multiply<U,
typename power_of_unit<N - 1, U>
::type>
type;
2801 template <
class U>
struct power_of_unit<1, U>
2817 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2832 template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value,
int>>
2835 static_assert(power >= 0,
"cpow cannot accept negative numbers. Try units::math::pow instead.");
2851 template<
typename T>
2858#if defined(_MSC_VER) && (_MSC_VER > 1800)
2863 template<
class... Args>
2883#if defined(UNIT_LIB_ENABLE_IOSTREAM)
2886 inline std::ostream&
operator<<(std::ostream& os,
const dB_t& obj) { os << obj() <<
" dB";
return os; }
2890#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
2894 template <
typename FormatContext>
2896 FormatContext& ctx) ->
decltype(ctx.out())
2898 auto out = ctx.out();
2911 template<
class UnitTypeLhs,
class UnitTypeRhs,
2912 std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2915 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2916 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2917 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2920 (lhs.template toLinearized<underlying_type>() * convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2924 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2927 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2928 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2932 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2935 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type;
2936 return UnitTypeRhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
2940 template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value,
int> = 0>
2943 using LhsUnits =
typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
2944 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2945 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2948 (lhs.template toLinearized<underlying_type>() / convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
2952 template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value,
int> = 0>
2955 using underlying_type =
typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
2956 return UnitTypeLhs(lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2960 template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value,
int> = 0>
2963 using RhsUnits =
typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
2964 using underlying_type =
typename units::traits::unit_t_traits<RhsUnits>::underlying_type;
2967 (lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
2977 template<
class Units>
2978 struct _unit_value_t {};
2984#ifdef FOR_DOXYGEN_PURPOSES_ONLY
2992 template<
typename T>
2993 struct unit_value_t_traits
2995 typedef typename T::unit_type unit_type;
2996 typedef typename T::ratio ratio;
3005 template<
typename T,
typename =
void>
3006 struct unit_value_t_traits
3008 typedef void unit_type;
3017 template<
typename T>
3018 struct unit_value_t_traits <T, typename
void_t<
3019 typename T::unit_type,
3020 typename T::ratio>
::type>
3022 typedef typename T::unit_type unit_type;
3023 typedef typename T::ratio ratio;
3045 template<
typename Units, std::u
intmax_t Num, std::u
intmax_t Denom = 1>
3065 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3067 std::is_base_of<units::detail::_unit_value_t<Units>, T>::value>
3069 template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
3077 template<
typename Category,
typename T>
3079 std::is_same<units::traits::base_unit_of<typename traits::unit_value_t_traits<T>::unit_type>, Category>::value>
3083 template<
typename Category,
typename T>
3091 template<
class U1,
class U2>
3092 struct unit_value_arithmetic
3097 using _UNIT1 =
typename traits::unit_value_t_traits<U1>::unit_type;
3098 using _UNIT2 =
typename traits::unit_value_t_traits<U2>::unit_type;
3099 using _CONV1 =
typename units::traits::unit_traits<_UNIT1>::conversion_ratio;
3100 using _CONV2 =
typename units::traits::unit_traits<_UNIT2>::conversion_ratio;
3101 using _RATIO1 =
typename traits::unit_value_t_traits<U1>::ratio;
3102 using _RATIO2 =
typename traits::unit_value_t_traits<U2>::ratio;
3103 using _RATIO2CONV =
typename std::ratio_divide<std::ratio_multiply<_RATIO2, _CONV2>, _CONV1>;
3104 using _PI_EXP = std::ratio_subtract<typename units::traits::unit_traits<_UNIT2>::pi_exponent_ratio,
typename units::traits::unit_traits<_UNIT1>::pi_exponent_ratio>;
3119 template<
class U1,
class U2>
3120 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>
3123 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3124 typedef typename Base::_UNIT1 unit_type;
3125 using ratio = std::ratio_add<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3138 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3139 return value(UsePi());
3150 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3168 template<
class U1,
class U2>
3169 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>
3172 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3174 typedef typename Base::_UNIT1 unit_type;
3175 using ratio = std::ratio_subtract<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
3188 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3189 return value(UsePi());
3200 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3218 template<
class U1,
class U2>
3220 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3221 typename traits::unit_value_t_traits<U2>::unit_type>::value, compound_unit<squared<typename traits::unit_value_t_traits<U1>::unit_type>>,
3222 compound_unit<typename traits::unit_value_t_traits<U1>::unit_type, typename traits::unit_value_t_traits<U2>::unit_type>>::type>
3225 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3228 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>>;
3239 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3240 return value(UsePi());
3251 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3268 template<
class U1,
class U2>
3270 units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3271 typename traits::unit_value_t_traits<U2>::unit_type>::value, dimensionless::scalar, compound_unit<typename traits::unit_value_t_traits<U1>::unit_type,
3272 inverse<typename traits::unit_value_t_traits<U2>::unit_type>>>::type>
3275 using Base = units::detail::unit_value_arithmetic<U1, U2>;
3278 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>>;
3289 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3290 return value(UsePi());
3301 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3317 template<
class U1,
int power>
3318 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>
3321 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3325 using pi_exponent = std::ratio_multiply<std::ratio<power>,
typename Base::_UNIT1::pi_exponent_ratio>;
3336 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3337 return value(UsePi());
3348 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3364 template<
class U1, std::
intmax_t Eps = 10000000000>
3365 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>>
3368 using Base = units::detail::unit_value_arithmetic<U1, U1>;
3383 using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
3384 return value(UsePi());
3395 static constexpr const unit_t<unit_type>
value(std::true_type)
noexcept
3420 template<
class UnitTypeLhs,
class UnitTypeRhs>
3421 UnitTypeLhs (
min)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3425 return (lhs < r ? lhs : r);
3428 template<
class UnitTypeLhs,
class UnitTypeRhs>
3429 UnitTypeLhs (
max)(
const UnitTypeLhs& lhs,
const UnitTypeRhs& rhs)
3433 return (lhs > r ? lhs : r);
3439# if _MSC_VER <= 1800
3440# pragma warning(pop)
3442# pragma pop_macro("constexpr")
3444# pragma pop_macro("noexcept")
3445# undef _ALLOW_KEYWORD_MACROS
3447# pragma pop_macro("pascal")
3450#if defined(UNIT_HAS_LITERAL_SUPPORT)
3455#if __has_include(<fmt/format.h>) && !defined(UNIT_LIB_DISABLE_FMT)
#define UNIT_LIB_DEFAULT_TYPE
Definition: base.h:60
#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)
Macro to create the is_category_unit type trait.
Definition: base.h:381
Container for values which represent quantities of a given unit.
Definition: base.h:1938
constexpr bool operator<(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than
Definition: base.h:2040
constexpr bool operator<=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
less-than or equal
Definition: base.h:2052
constexpr unit_t< U > convert() const noexcept
conversion
Definition: base.h:2155
unit_t & operator=(const Ty &rhs) noexcept
assignment
Definition: base.h:2027
constexpr unit_t(const std::chrono::duration< Rep, Period > &value) noexcept
chrono constructor
Definition: base.h:1991
constexpr underlying_type value() const noexcept
unit value
Definition: base.h:2119
constexpr unit_t(const Ty value) noexcept
constructor
Definition: base.h:1980
constexpr unit_t(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
copy constructor (converting)
Definition: base.h:2003
constexpr const char * name() const noexcept
returns the unit name
Definition: base.h:2195
constexpr Ty toLinearized() const noexcept
linearized unit value
Definition: base.h:2140
constexpr Ty to() const noexcept
unit value
Definition: base.h:2129
constexpr bool operator!=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
inequality
Definition: base.h:2110
Units unit_type
Type of unit the unit_t represents (e.g. meters)
Definition: base.h:1952
constexpr bool operator>(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than
Definition: base.h:2064
T value_type
Synonym for underlying type. May be removed in future versions. Prefer underlying_type.
Definition: base.h:1951
constexpr bool operator==(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
equality
Definition: base.h:2089
constexpr unit_t(const T value, const Args &... args) noexcept
constructor
Definition: base.h:1969
constexpr const char * abbreviation() const noexcept
returns the unit abbreviation
Definition: base.h:2203
NonLinearScale< T > non_linear_scale_type
Type of the non-linear scale of the unit_t (e.g. linear_scale)
Definition: base.h:1949
NonLinearScale< T > nls
Definition: base.h:1944
constexpr bool operator>=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) const noexcept
greater-than or equal
Definition: base.h:2076
constexpr unit_t()=default
default constructor.
unit_t & operator=(const unit_t< UnitsRhs, Ty, NlsRhs > &rhs) noexcept
assignment
Definition: base.h:2015
T underlying_type
Type of the underlying storage of the unit_t (e.g. double)
Definition: base.h:1950
typename std::enable_if< B, T >::type enable_if_t
Definition: core.h:256
constexpr T unit_cast(const Units &value) noexcept
Casts a unit container to an arithmetic type.
Definition: base.h:2404
static constexpr T convert(const T &value) noexcept
converts a value from one type to another.
Definition: base.h:1660
typename units::detail::Sqrt< Ratio, std::ratio< 1, Eps > >::type ratio_sqrt
Calculate square root of a ratio at compile-time.
Definition: base.h:1368
constexpr UnitType make_unit(const T value) noexcept
Constructs a unit container from an arithmetic type.
Definition: base.h:2229
typename units::detail::prefix< std::peta, U >::type peta
Represents the type of class U with the metric 'peta' prefix appended.
Definition: base.h:1503
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:1516
typename units::detail::prefix< std::milli, U >::type milli
Represents the type of class U with the metric 'milli' prefix appended.
Definition: base.h:1494
typename units::detail::inverse_impl< U >::type inverse
represents the inverse unit type of class U.
Definition: base.h:1146
typename units::detail::prefix< std::micro, U >::type micro
Represents the type of class U with the metric 'micro' prefix appended.
Definition: base.h:1493
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:1514
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:1518
typename units::detail::prefix< std::giga, U >::type giga
Represents the type of class U with the metric 'giga' prefix appended.
Definition: base.h:1501
typename units::detail::squared_impl< U >::type squared
represents the unit type of class U squared
Definition: base.h:1177
typename units::detail::prefix< std::deca, U >::type deca
Represents the type of class U with the metric 'deca' prefix appended.
Definition: base.h:1497
typename units::detail::prefix< std::deci, U >::type deci
Represents the type of class U with the metric 'deci' prefix appended.
Definition: base.h:1496
typename units::detail::cubed_impl< U >::type cubed
represents the type of class U cubed.
Definition: base.h:1207
typename units::detail::prefix< std::femto, U >::type femto
Represents the type of class U with the metric 'femto' prefix appended.
Definition: base.h:1490
typename units::detail::prefix< std::pico, U >::type pico
Represents the type of class U with the metric 'pico' prefix appended.
Definition: base.h:1491
typename units::detail::prefix< std::tera, U >::type tera
Represents the type of class U with the metric 'tera' prefix appended.
Definition: base.h:1502
typename units::detail::prefix< std::hecto, U >::type hecto
Represents the type of class U with the metric 'hecto' prefix appended.
Definition: base.h:1498
typename units::detail::prefix< std::atto, U >::type atto
Represents the type of class U with the metric 'atto' prefix appended.
Definition: base.h:1489
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:1515
typename units::detail::prefix< std::exa, U >::type exa
Represents the type of class U with the metric 'exa' prefix appended.
Definition: base.h:1504
typename units::detail::sqrt_impl< U, Eps >::type square_root
represents the square root of type class U.
Definition: base.h:1413
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:1517
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:1513
typename units::detail::prefix< std::centi, U >::type centi
Represents the type of class U with the metric 'centi' prefix appended.
Definition: base.h:1495
typename units::detail::prefix< std::nano, U >::type nano
Represents the type of class U with the metric 'nano' prefix appended.
Definition: base.h:1492
typename units::detail::prefix< std::mega, U >::type mega
Represents the type of class U with the metric 'mega' prefix appended.
Definition: base.h:1500
typename units::detail::prefix< std::kilo, U >::type kilo
Represents the type of class U with the metric 'kilo' prefix appended.
Definition: base.h:1499
UnitType abs(const UnitType x) noexcept
Compute absolute value.
Definition: math.h:721
dimensionless::scalar_t log10(const ScalarUnit x) noexcept
Compute common logarithm.
Definition: math.h:365
typename units::detail::compound_impl< U, Us... >::type compound_unit
Represents a unit type made up from other units.
Definition: base.h:1446
detail namespace with internal helper functions
Definition: ranges.h:23
void void_t
Definition: core.h:1510
@ value
the parser finished reading a JSON value
constexpr auto count() -> size_t
Definition: core.h:1203
type
Definition: core.h:556
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > > time_unit
Represents an SI base unit of time.
Definition: base.h:809
base_unit< detail::meter_ratio< 0 >, std::ratio< 1 > > mass_unit
Represents an SI base unit of mass.
Definition: base.h:808
base_unit< detail::meter_ratio<-3 >, std::ratio< 1 > > density_unit
Represents an SI derived unit of density.
Definition: base.h:846
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:834
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:821
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:832
base_unit< detail::meter_ratio< 1 > > length_unit
Represents an SI base unit of length.
Definition: base.h:807
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:814
base_unit concentration_unit
Represents a unit of concentration.
Definition: base.h:847
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > energy_unit
Represents an SI derived unit of energy.
Definition: base.h:828
base_unit< detail::meter_ratio< 3 > > volume_unit
Represents an SI derived unit of volume.
Definition: base.h:845
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:838
base_unit dimensionless_unit
Represents a quantity with no dimension.
Definition: base.h:803
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:848
base_unit< detail::meter_ratio<-1 >, std::ratio< 1 >, std::ratio<-2 > > pressure_unit
Represents an SI derived unit of pressure.
Definition: base.h:826
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-2 > > acceleration_unit
Represents an SI derived unit of acceleration.
Definition: base.h:822
base_unit scalar_unit
Represents a quantity with no dimension.
Definition: base.h:802
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 > > power_unit
Represents an SI derived unit of power.
Definition: base.h:829
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > frequency_unit
Represents an SI derived unit of frequency.
Definition: base.h:819
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:810
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:811
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:827
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:818
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:813
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:824
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:830
base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > > radioactivity_unit
Represents an SI derived unit of radioactivity.
Definition: base.h:839
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:837
base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > > torque_unit
Represents an SI derived unit of torque.
Definition: base.h:843
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:836
base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-1 > > velocity_unit
Represents an SI derived unit of velocity.
Definition: base.h:820
base_unit< detail::meter_ratio< 1 >, std::ratio< 1 >, std::ratio<-2 > > force_unit
Represents an SI derived unit of force.
Definition: base.h:825
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:823
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:849
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:831
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:833
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:835
base_unit< detail::meter_ratio< 2 > > area_unit
Represents an SI derived unit of area.
Definition: base.h:844
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:812
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:93
unit_t< scalar, UNIT_LIB_DEFAULT_TYPE, decibel_scale > dB_t
Definition: base.h:2880
unit< std::ratio< 1 >, units::category::dimensionless_unit > dimensionless
Definition: base.h:2523
dB_t dBi_t
Definition: base.h:2881
scalar_t dimensionless_t
Definition: base.h:2526
unit_t< scalar > scalar_t
Definition: base.h:2525
unit< std::ratio< 1 >, units::category::scalar_unit > scalar
Definition: base.h:2522
UnitTypeLhs() max(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3429
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:2833
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:2818
UnitTypeLhs() min(const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
Definition: base.h:3421
constexpr bool has_decibel_scale_v
Definition: base.h:2451
constexpr bool is_convertible_unit_v
Definition: base.h:1543
constexpr bool has_linear_scale_v
Definition: base.h:2429
constexpr bool is_unit_value_t_category_v
Definition: base.h:3084
constexpr bool is_same_scale_v
Definition: base.h:2475
constexpr bool is_unit_v
Definition: base.h:732
constexpr bool is_unit_t_v
Definition: base.h:1878
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:944
constexpr bool is_ratio_v
Definition: base.h:604
constexpr bool is_unit_value_t_v
Definition: base.h:3070
Unit Conversion Library namespace.
Definition: angle.h:31
unit_t< Units, T, NonLinearScale > & operator*=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2315
unit_t< Units, T, NonLinearScale > & operator/=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2325
constexpr bool operator!=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2728
unit_t< Units, T, NonLinearScale > & operator+=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2293
constexpr const char * abbreviation(const T &)
constexpr bool operator==(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2714
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:2656
constexpr const char * name(const T &)
constexpr bool operator<(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2776
unit_t< Units, T, NonLinearScale > & operator++(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2347
unit_t< Units, T, NonLinearScale > & operator-=(unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
Definition: base.h:2304
constexpr bool operator<=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2764
unit_t< Units, T, NonLinearScale > & operator--(unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2371
constexpr bool operator>=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2740
constexpr bool operator>(const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
Definition: base.h:2752
constexpr unit_t< Units, T, NonLinearScale > operator-(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2364
constexpr unit_t< Units, T, NonLinearScale > operator+(const unit_t< Units, T, NonLinearScale > &u) noexcept
Definition: base.h:2340
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:2600
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:769
Kilogram kilogram_ratio
Definition: base.h:781
Radian radian_ratio
Definition: base.h:783
Kelvin kelvin_ratio
Definition: base.h:785
Ampere ampere_ratio
Definition: base.h:784
Byte byte_ratio
Definition: base.h:788
Candela candela_ratio
Definition: base.h:787
Second second_ratio
Definition: base.h:782
Meter meter_ratio
Definition: base.h:780
Mole mole_ratio
Definition: base.h:786
unit_t scale for representing decibel values.
Definition: base.h:2853
decibel_scale & operator=(const decibel_scale &)=default
constexpr decibel_scale(const T value) noexcept
Definition: base.h:2862
constexpr decibel_scale(const T value, std::true_type, Args &&...) noexcept
Definition: base.h:2864
constexpr decibel_scale()=default
T m_value
linearized value
Definition: base.h:2867
constexpr T operator()() const noexcept
Definition: base.h:2865
constexpr decibel_scale(const decibel_scale &)=default
unit_t scale which is linear
Definition: base.h:2499
constexpr T operator()() const noexcept
returns value.
Definition: base.h:2510
UNIT_LIB_DEFAULT_TYPE m_value
linearized value.
Definition: base.h:2512
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:2509
Trait which tests whether a type is inherited from a decibel scale.
Definition: base.h:2449
Trait which tests whether a type is inherited from a linear scale.
Definition: base.h:2427
Trait which tests if a class is a base_unit type.
Definition: base.h:704
Trait which tests whether two container types derived from unit_t are convertible to each other.
Definition: base.h:1838
Trait which checks whether two units can be converted to each other.
Definition: base.h:1541
Trait which tests that class T meets the requirements for a non-linear scale.
Definition: base.h:1761
Trait that tests whether a type represents a std::ratio.
Definition: base.h:602
Trait which tests whether two types has the same non-linear scale.
Definition: base.h:2473
Traits which tests if a class is a unit
Definition: base.h:1876
Trait which tests whether type T is a unit_value_t with a unit type in the given category.
Definition: base.h:3080
Trait which tests whether a type is a unit_value_t representing the given unit type.
Definition: base.h:3068
Traits which tests if a class is a unit
Definition: base.h:730
adds two unit_value_t types at compile-time
Definition: base.h:3121
static constexpr const unit_t< unit_type > value() noexcept
Value of sum.
Definition: base.h:3136
divides two unit_value_t types at compile-time
Definition: base.h:3273
static constexpr const unit_t< unit_type > value() noexcept
Value of quotient.
Definition: base.h:3287
multiplies two unit_value_t types at compile-time
Definition: base.h:3223
static constexpr const unit_t< unit_type > value() noexcept
Value of product.
Definition: base.h:3237
raises unit_value_to a power at compile-time
Definition: base.h:3319
static constexpr const unit_t< unit_type > value() noexcept
Value of exponentiation.
Definition: base.h:3334
calculates square root of unit_value_t at compile-time
Definition: base.h:3366
static constexpr const unit_t< unit_type > value() noexcept
Value of square root.
Definition: base.h:3381
subtracts two unit_value_t types at compile-time
Definition: base.h:3170
static constexpr const unit_t< unit_type > value() noexcept
Value of difference.
Definition: base.h:3186
Stores a rational unit value as a compile-time constant.
Definition: base.h:3047
Units unit_type
Definition: base.h:3048
std::ratio< Num, Denom > ratio
Definition: base.h:3049
static constexpr const unit_t< Units > value()
Definition: base.h:3052
Type representing an arbitrary unit.
Definition: base.h:896
std::ratio_add< std::ratio_multiply< typename BaseUnit::conversion_ratio, Translation >, typename BaseUnit::translation_ratio > translation_ratio
Definition: base.h:904
std::ratio_multiply< typename BaseUnit::conversion_ratio, Conversion > conversion_ratio
Definition: base.h:902
units::traits::unit_traits< BaseUnit >::base_unit_type base_unit_type
Definition: base.h:901
std::ratio_add< typename BaseUnit::pi_exponent_ratio, PiExponent > pi_exponent_ratio
Definition: base.h:903
auto format_to(OutputIt out, const text_style &ts, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
\rst Formats arguments with the given text_style, writes the result to the output iterator out and re...
Definition: color.h:568
std::basic_string< Char > format(const text_style &ts, const S &format_str, const Args &... args)
\rst Formats arguments and returns the result as a string using ANSI escape sequences to specify text...
Definition: color.h:534