units.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------
//
//  Units: A compile-time c++14 unit conversion library with no dependencies
//
//--------------------------------------------------------------------------------------------------
//
// The MIT License (MIT)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
// and associated documentation files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//--------------------------------------------------------------------------------------------------
//
// Copyright (c) 2016 Nic Holthaus
//
//--------------------------------------------------------------------------------------------------
//
// ATTRIBUTION:
// Parts of this work have been adapted from:
// http://stackoverflow.com/questions/35069778/create-comparison-trait-for-template-classes-whose-parameters-are-in-a-different
// http://stackoverflow.com/questions/28253399/check-traits-for-all-variadic-template-arguments/28253503
// http://stackoverflow.com/questions/36321295/rational-approximation-of-square-root-of-stdratio-at-compile-time?noredirect=1#comment60266601_36321295
//
//--------------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------------
 
#pragma once
 
#ifndef units_h__
#define units_h__
 
#ifdef _MSC_VER
#   pragma push_macro("pascal")
#   undef pascal
#   if _MSC_VER <= 1800
#       define _ALLOW_KEYWORD_MACROS
#       pragma warning(push)
#       pragma warning(disable : 4520)
#       pragma push_macro("constexpr")
#       define constexpr /*constexpr*/
#       pragma push_macro("noexcept")
#       define noexcept throw()
#   endif // _MSC_VER < 1800
#endif // _MSC_VER
 
#if defined(__MINGW64__) || defined(__MINGW32__)
#   pragma push_macro("pascal")
#   undef pascal
#endif // __MINGW64__ or __MINGW32__
 
#if !defined(_MSC_VER) || _MSC_VER > 1800
#   define UNIT_HAS_LITERAL_SUPPORT
#   define UNIT_HAS_VARIADIC_TEMPLATE_SUPPORT
#endif
 
#ifndef UNIT_LIB_DEFAULT_TYPE
#   define UNIT_LIB_DEFAULT_TYPE double
#endif
 
//--------------------
//  INCLUDES
//--------------------
 
#include <chrono>
#include <cstddef>
#include <ratio>
#include <type_traits>
#include <cstdint>
#include <cmath>
#include <limits>
 
#if !defined(UNIT_LIB_DISABLE_IOSTREAM)
    #include <iostream>
    #include <string>
    #include <locale>
 
    //------------------------------
    //  STRING FORMATTER
    //------------------------------
 
    namespace units
    {
        namespace detail
        {
            template <typename T> std::string to_string(const T& t)
            {
                std::string str{ std::to_string(t) };
                int offset{ 1 };
 
                // remove trailing decimal points for integer value units. Locale aware!
                struct lconv * lc;
                lc = localeconv();
                char decimalPoint = *lc->decimal_point;
                if (str.find_last_not_of('0') == str.find(decimalPoint)) { offset = 0; }
                str.erase(str.find_last_not_of('0') + offset, std::string::npos);
                return str;
            }
        }
    }
#endif
 
namespace units
{
    template<typename T> inline constexpr const char* name(const T&);
    template<typename T> inline constexpr const char* name_plural(const T&);
    template<typename T> inline constexpr const char* abbreviation(const T&);
}
 
//------------------------------
//  MACROS
//------------------------------

#define UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, /*definition*/...)\
    namespace namespaceName\
    {\
  typedef __VA_ARGS__ namePlural; \
  typedef namePlural nameSingular; \
  typedef namePlural abbreviation; \
    }

#define UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
    namespace namespaceName\
    {\
  typedef unit_t<nameSingular> nameSingular ## _t; \
    }

#define UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular, underlyingType)\
    namespace namespaceName\
    {\
  typedef unit_t<nameSingular,underlyingType> nameSingular ## _t; \
    }

#if defined(UNIT_LIB_DISABLE_IOSTREAM)
    #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)
#else
    #define UNIT_ADD_IO(namespaceName, nameSingular, abbrev)\
    namespace namespaceName\
    {\
        inline std::ostream& operator<<(std::ostream& os, const nameSingular ## _t& obj) \
        {\
            os << obj() << " "#abbrev; return os; \
        }\
        inline std::string to_string(const nameSingular ## _t& obj)\
        {\
            return units::detail::to_string(obj()) + std::string(" "#abbrev);\
        }\
    }
#endif

#define UNIT_ADD_NAME(namespaceName, nameSingular, namePlural, abbrev)\
template<> inline constexpr const char* name(const namespaceName::nameSingular ## _t&)\
{\
    return #nameSingular;\
}\
template<> inline constexpr const char* abbreviation(const namespaceName::nameSingular ## _t&)\
{\
    return #abbrev;\
}\
template<> inline constexpr const char* name_plural(const namespaceName::nameSingular ## _t&)\
{\
    return #namePlural;\
}

#if defined(UNIT_HAS_LITERAL_SUPPORT)
    #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)\
    namespace literals\
    {\
        inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation(long double d)\
        {\
            return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
        }\
        inline constexpr namespaceName::nameSingular ## _t operator""_ ## abbreviation (unsigned long long d)\
        {\
            return namespaceName::nameSingular ## _t(static_cast<namespaceName::nameSingular ## _t::underlying_type>(d));\
        }\
    }
#else
    #define UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)
#endif

#define UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, /*definition*/...)\
    UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
    UNIT_ADD_UNIT_DEFINITION(namespaceName,nameSingular)\
    UNIT_ADD_NAME(namespaceName,nameSingular,namePlural, abbreviation)\
    UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
    UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)

#define UNIT_ADD_WITH_CUSTOM_TYPE(namespaceName, nameSingular, namePlural, abbreviation, underlyingType, /*definition*/...)\
    UNIT_ADD_UNIT_TAGS(namespaceName,nameSingular, namePlural, abbreviation, __VA_ARGS__)\
    UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName,nameSingular,underlyingType)\
    UNIT_ADD_IO(namespaceName,nameSingular, abbreviation)\
    UNIT_ADD_LITERALS(namespaceName,nameSingular, abbreviation)

#define UNIT_ADD_DECIBEL(namespaceName, nameSingular, abbreviation)\
    namespace namespaceName\
    {\
  typedef unit_t<nameSingular, UNIT_LIB_DEFAULT_TYPE, units::decibel_scale> abbreviation ## _t; \
    }\
    UNIT_ADD_IO(namespaceName, abbreviation, abbreviation)\
    UNIT_ADD_LITERALS(namespaceName, abbreviation, abbreviation)

 
#define UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
    namespace traits\
    {\
\
        namespace detail\
        {\
            template<typename T> struct is_ ## unitCategory ## _unit_impl : std::false_type {};\
            template<typename C, typename U, typename P, typename T>\
            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 {};\
            template<typename U, typename S, template<typename> class N>\
            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 {};\
        }\
\
    }
 
#if defined(UNIT_HAS_VARIADIC_TEMPLATE_SUPPORT)
#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)\
    namespace traits\
    {\
        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> {};\
    }
#else
#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)\
    namespace traits\
    {\
            template<typename T1, typename T2 = T1, typename T3 = T1>\
            struct is_ ## unitCategory ## _unit : std::integral_constant<bool, units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T1>::type>::value &&\
                units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T2>::type>::value &&\
                units::traits::detail::is_ ## unitCategory ## _unit_impl<typename std::decay<T3>::type>::value>{};\
    }
#endif
 
#define UNIT_ADD_CATEGORY_TRAIT(unitCategory)\
    UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\
\
\
\
\
    UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)

#define UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, /*definition*/...)\
    UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
    UNIT_ADD(namespaceName, femto ## nameSingular, femto ## namePlural, f ## abbreviation, femto<namePlural>)\
    UNIT_ADD(namespaceName, pico ## nameSingular, pico ## namePlural, p ## abbreviation, pico<namePlural>)\
    UNIT_ADD(namespaceName, nano ## nameSingular, nano ## namePlural, n ## abbreviation, nano<namePlural>)\
    UNIT_ADD(namespaceName, micro ## nameSingular, micro ## namePlural, u ## abbreviation, micro<namePlural>)\
    UNIT_ADD(namespaceName, milli ## nameSingular, milli ## namePlural, m ## abbreviation, milli<namePlural>)\
    UNIT_ADD(namespaceName, centi ## nameSingular, centi ## namePlural, c ## abbreviation, centi<namePlural>)\
    UNIT_ADD(namespaceName, deci ## nameSingular, deci ## namePlural, d ## abbreviation, deci<namePlural>)\
    UNIT_ADD(namespaceName, deca ## nameSingular, deca ## namePlural, da ## abbreviation, deca<namePlural>)\
    UNIT_ADD(namespaceName, hecto ## nameSingular, hecto ## namePlural, h ## abbreviation, hecto<namePlural>)\
    UNIT_ADD(namespaceName, kilo ## nameSingular, kilo ## namePlural, k ## abbreviation, kilo<namePlural>)\
    UNIT_ADD(namespaceName, mega ## nameSingular, mega ## namePlural, M ## abbreviation, mega<namePlural>)\
    UNIT_ADD(namespaceName, giga ## nameSingular, giga ## namePlural, G ## abbreviation, giga<namePlural>)\
    UNIT_ADD(namespaceName, tera ## nameSingular, tera ## namePlural, T ## abbreviation, tera<namePlural>)\
    UNIT_ADD(namespaceName, peta ## nameSingular, peta ## namePlural, P ## abbreviation, peta<namePlural>)\


#define UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, /*definition*/...)\
    UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, __VA_ARGS__)\
    UNIT_ADD(namespaceName, kibi ## nameSingular, kibi ## namePlural, Ki ## abbreviation, kibi<namePlural>)\
    UNIT_ADD(namespaceName, mebi ## nameSingular, mebi ## namePlural, Mi ## abbreviation, mebi<namePlural>)\
    UNIT_ADD(namespaceName, gibi ## nameSingular, gibi ## namePlural, Gi ## abbreviation, gibi<namePlural>)\
    UNIT_ADD(namespaceName, tebi ## nameSingular, tebi ## namePlural, Ti ## abbreviation, tebi<namePlural>)\
    UNIT_ADD(namespaceName, pebi ## nameSingular, pebi ## namePlural, Pi ## abbreviation, pebi<namePlural>)\
    UNIT_ADD(namespaceName, exbi ## nameSingular, exbi ## namePlural, Ei ## abbreviation, exbi<namePlural>)
 
//--------------------
//  UNITS NAMESPACE
//--------------------

namespace units
{
    //----------------------------------
    //  DOXYGEN
    //----------------------------------







 
    //------------------------------
    //  FORWARD DECLARATIONS
    //------------------------------
    // DOXYGEN IGNORE
    namespace constants
    {
        namespace detail
        {
            static constexpr const UNIT_LIB_DEFAULT_TYPE PI_VAL = 3.14159265358979323846264338327950288419716939937510;
        }
    } // END DOXYGEN IGNORE
 
    //------------------------------
    //  RATIO TRAITS
    //------------------------------

    // DOXYGEN IGNORE
    namespace detail
    {
        template<class T>
        struct has_num_impl
        {
            template<class U>
            static constexpr auto test(U*)->std::is_integral<decltype(U::num)> {return std::is_integral<decltype(U::num)>{}; }
            template<typename>
            static constexpr std::false_type test(...) { return std::false_type{}; }
 
            using type = decltype(test<T>(0));
        };
    }

    template<class T>
    struct has_num : units::detail::has_num_impl<T>::type {};
 
    namespace detail
    {
        template<class T>
        struct has_den_impl
        {
            template<class U>
            static constexpr auto test(U*)->std::is_integral<decltype(U::den)> { return std::is_integral<decltype(U::den)>{}; }
            template<typename>
            static constexpr std::false_type test(...) { return std::false_type{}; }
 
            using type = decltype(test<T>(0));
        };
    }

    template<class T>
    struct has_den : units::detail::has_den_impl<T>::type {};
 // END DOXYGEN IGNORE
 
    namespace traits
    {
        template<class T>
        struct is_ratio : std::integral_constant<bool,
            has_num<T>::value &&
            has_den<T>::value>
        {};
    }
 
    //------------------------------
    //  UNIT TRAITS
    //------------------------------
    // DOXYGEN IGNORE
    template<class ...>
    struct void_t { typedef void type; };

    template<bool...> struct bool_pack {};

    template<bool... Args>
    struct all_true : std::is_same<units::bool_pack<true, Args...>, units::bool_pack<Args..., true>> {}; // DOXYGEN IGNORE

    namespace traits
    {
#ifdef FOR_DOXYGEN_PURPOSES_ONLY
        template<class T>
        struct unit_traits
        {
            typedef typename T::base_unit_type base_unit_type;                                          
            typedef typename T::conversion_ratio conversion_ratio;                                      
            typedef typename T::pi_exponent_ratio pi_exponent_ratio;                                    
            typedef typename T::translation_ratio translation_ratio;                                    
        };
#endif    // DOXYGEN IGNORE
        template<class T, typename = void>
        struct unit_traits
        {
            typedef void base_unit_type;
            typedef void conversion_ratio;
            typedef void pi_exponent_ratio;
            typedef void translation_ratio;
        };
 
        template<class T>
        struct unit_traits
            <T, typename void_t<
            typename T::base_unit_type,
            typename T::conversion_ratio,
            typename T::pi_exponent_ratio,
            typename T::translation_ratio>::type>
        {
            typedef typename T::base_unit_type base_unit_type;                                          
            typedef typename T::conversion_ratio conversion_ratio;                                      
            typedef typename T::pi_exponent_ratio pi_exponent_ratio;                                    
            typedef typename T::translation_ratio translation_ratio;                                    
        }; // END DOXYGEN IGNORE
    }
    // DOXYGEN IGNORE
    namespace detail
    {
        struct _base_unit_t {};
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
        template<class T>
        struct is_base_unit : std::is_base_of<units::detail::_base_unit_t, T> {};
    }
    // DOXYGEN IGNORE
    namespace detail
    {
        struct _unit {};
 
        template<std::intmax_t Num, std::intmax_t Den = 1>
        using meter_ratio = std::ratio<Num, Den>;
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
        template<class T>
        struct is_unit : std::is_base_of<units::detail::_unit, T>::type {};
    }
 // end of TypeTraits
 
    //------------------------------
    //  BASE UNIT CLASS
    //------------------------------

    template<class Meter = detail::meter_ratio<0>,
    class Kilogram = std::ratio<0>,
    class Second = std::ratio<0>,
    class Radian = std::ratio<0>,
    class Ampere = std::ratio<0>,
    class Kelvin = std::ratio<0>,
    class Mole = std::ratio<0>,
    class Candela = std::ratio<0>,
    class Byte = std::ratio<0>>
    struct base_unit : units::detail::_base_unit_t
    {
        static_assert(traits::is_ratio<Meter>::value, "Template parameter `Meter` must be a `std::ratio` representing the exponent of meters the unit has");
        static_assert(traits::is_ratio<Kilogram>::value, "Template parameter `Kilogram` must be a `std::ratio` representing the exponent of kilograms the unit has");
        static_assert(traits::is_ratio<Second>::value, "Template parameter `Second` must be a `std::ratio` representing the exponent of seconds the unit has");
        static_assert(traits::is_ratio<Ampere>::value, "Template parameter `Ampere` must be a `std::ratio` representing the exponent of amperes the unit has");
        static_assert(traits::is_ratio<Kelvin>::value, "Template parameter `Kelvin` must be a `std::ratio` representing the exponent of kelvin the unit has");
        static_assert(traits::is_ratio<Candela>::value, "Template parameter `Candela` must be a `std::ratio` representing the exponent of candelas the unit has");
        static_assert(traits::is_ratio<Mole>::value, "Template parameter `Mole` must be a `std::ratio` representing the exponent of moles the unit has");
        static_assert(traits::is_ratio<Radian>::value, "Template parameter `Radian` must be a `std::ratio` representing the exponent of radians the unit has");
        static_assert(traits::is_ratio<Byte>::value, "Template parameter `Byte` must be a `std::ratio` representing the exponent of bytes the unit has");
 
        typedef Meter meter_ratio;
        typedef Kilogram kilogram_ratio;
        typedef Second second_ratio;
        typedef Radian radian_ratio;
        typedef Ampere ampere_ratio;
        typedef Kelvin kelvin_ratio;
        typedef Mole mole_ratio;
        typedef Candela candela_ratio;
        typedef Byte byte_ratio;
    };
 
    //------------------------------
    //  UNIT CATEGORIES
    //------------------------------

    namespace category
    {
        // SCALAR (DIMENSIONLESS) TYPES
        typedef base_unit<> scalar_unit;          
        typedef base_unit<> dimensionless_unit;    
 
        // SI BASE UNIT TYPES
        //                  METERS          KILOGRAMS       SECONDS         RADIANS         AMPERES         KELVIN          MOLE            CANDELA         BYTE        ---     CATEGORY
        typedef base_unit<detail::meter_ratio<1>>                                                                                                                                       length_unit;                 
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<1>>                                                                                                                      mass_unit;                     
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<1>>                                                                                                      time_unit;                     
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<0>,  std::ratio<1>>                                                                                      angle_unit;                       
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<0>,  std::ratio<0>,  std::ratio<1>>                                                                      current_unit;                   
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<0>,  std::ratio<0>,  std::ratio<0>,  std::ratio<1>>                                                      temperature_unit;               
        typedef 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;                   
        typedef 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;         
 
        // SI DERIVED UNIT TYPES
        //                  METERS          KILOGRAMS       SECONDS         RADIANS         AMPERES         KELVIN          MOLE            CANDELA         BYTE        ---     CATEGORY
        typedef 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;               
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<-1>>                                                                                                     frequency_unit;                   
        typedef base_unit<detail::meter_ratio<1>,   std::ratio<0>,  std::ratio<-1>>                                                                                                     velocity_unit;                 
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<-1>, std::ratio<1>>                                                                                      angular_velocity_unit;         
        typedef base_unit<detail::meter_ratio<1>,   std::ratio<0>,  std::ratio<-2>>                                                                                                     acceleration_unit;             
        typedef base_unit<detail::meter_ratio<1>,   std::ratio<0>,  std::ratio<-3>>                                                                                                     jerk_unit;                      
        typedef base_unit<detail::meter_ratio<1>,   std::ratio<1>,  std::ratio<-2>>                                                                                                     force_unit;                       
        typedef base_unit<detail::meter_ratio<-1>, std::ratio<1>,  std::ratio<-2>>                                                                                                     pressure_unit;                 
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<1>,  std::ratio<0>,  std::ratio<1>>                                                                      charge_unit;                 
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-2>>                                                                                                     energy_unit;                 
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-3>>                                                                                                     power_unit;                       
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-3>, std::ratio<0>,  std::ratio<-1>>                                                                     voltage_unit;                   
        typedef base_unit<detail::meter_ratio<-2>, std::ratio<-1>, std::ratio<4>,  std::ratio<0>,  std::ratio<2>>                                                                      capacitance_unit;               
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-3>, std::ratio<0>,  std::ratio<-2>>                                                                     impedance_unit;                   
        typedef base_unit<detail::meter_ratio<-2>, std::ratio<-1>, std::ratio<3>,  std::ratio<0>,  std::ratio<2>>                                                                      conductance_unit;               
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-2>, std::ratio<0>,  std::ratio<-1>>                                                                     magnetic_flux_unit;               
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<1>,  std::ratio<-2>, std::ratio<0>,  std::ratio<-1>>                                                                     magnetic_field_strength_unit;   
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-2>, std::ratio<0>,  std::ratio<-2>>                                                                     inductance_unit;             
        typedef 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;               
        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;               
        typedef base_unit<detail::meter_ratio<0>,   std::ratio<0>,  std::ratio<-1>>                                                                                                     radioactivity_unit;               
 
        // OTHER UNIT TYPES
        //                  METERS          KILOGRAMS       SECONDS         RADIANS         AMPERES         KELVIN          MOLE            CANDELA         BYTE        ---     CATEGORY
        typedef base_unit<detail::meter_ratio<2>,   std::ratio<1>,  std::ratio<-2>>                                                                                                     torque_unit;                 
        typedef base_unit<detail::meter_ratio<2>>                                                                                                                                       area_unit;                     
        typedef base_unit<detail::meter_ratio<3>>                                                                                                                                       volume_unit;                 
        typedef base_unit<detail::meter_ratio<-3>, std::ratio<1>>                                                                                                                      density_unit;                   
        typedef base_unit<>                                                                                                                                                      concentration_unit;               
        typedef 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;                     
        typedef 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;     
    }
 
    //------------------------------
    //  UNIT CLASSES
    //------------------------------
    // DOXYGEN IGNORE
    template <class, class, class, class> struct unit;
    template<class Conversion, class... Exponents, class PiExponent, class Translation>
    struct unit<Conversion, base_unit<Exponents...>, PiExponent, Translation> : units::detail::_unit
    {
        static_assert(traits::is_ratio<Conversion>::value, "Template parameter `Conversion` must be a `std::ratio` representing the conversion factor to `BaseUnit`.");
        static_assert(traits::is_ratio<PiExponent>::value, "Template parameter `PiExponent` must be a `std::ratio` representing the exponents of Pi the unit has.");
        static_assert(traits::is_ratio<Translation>::value, "Template parameter `Translation` must be a `std::ratio` representing an additive translation required by the unit conversion.");
 
        typedef typename units::base_unit<Exponents...> base_unit_type;
        typedef Conversion conversion_ratio;
        typedef Translation translation_ratio;
        typedef PiExponent pi_exponent_ratio;
    }; // END DOXYGEN IGNORE

    template<class Conversion, class BaseUnit, class PiExponent = std::ratio<0>, class Translation = std::ratio<0>>
    struct unit : units::detail::_unit
    {
        static_assert(traits::is_unit<BaseUnit>::value, "Template parameter `BaseUnit` must be a `unit` type.");
        static_assert(traits::is_ratio<Conversion>::value, "Template parameter `Conversion` must be a `std::ratio` representing the conversion factor to `BaseUnit`.");
        static_assert(traits::is_ratio<PiExponent>::value, "Template parameter `PiExponent` must be a `std::ratio` representing the exponents of Pi the unit has.");
 
        typedef typename units::traits::unit_traits<BaseUnit>::base_unit_type base_unit_type;
        typedef typename std::ratio_multiply<typename BaseUnit::conversion_ratio, Conversion> conversion_ratio;
        typedef typename std::ratio_add<typename BaseUnit::pi_exponent_ratio, PiExponent> pi_exponent_ratio;
        typedef typename std::ratio_add<std::ratio_multiply<typename BaseUnit::conversion_ratio, Translation>, typename BaseUnit::translation_ratio> translation_ratio;
    };
 
    //------------------------------
    //  BASE UNIT MANIPULATORS
    //------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class> struct base_unit_of_impl;
        template<class Conversion, class BaseUnit, class PiExponent, class Translation>
        struct base_unit_of_impl<unit<Conversion, BaseUnit, PiExponent, Translation>> : base_unit_of_impl<BaseUnit> {};
        template<class... Exponents>
        struct base_unit_of_impl<base_unit<Exponents...>>
        {
            typedef base_unit<Exponents...> type;
        };
        template<>
        struct base_unit_of_impl<void>
        {
            typedef void type;
        };
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
        template<class U>
        using base_unit_of = typename units::detail::base_unit_of_impl<U>::type;
    }
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class, class> struct base_unit_multiply_impl;
        template<class... Exponents1, class... Exponents2>
        struct base_unit_multiply_impl<base_unit<Exponents1...>, base_unit<Exponents2...>> {
            using type = base_unit<std::ratio_add<Exponents1, Exponents2>...>;
        };

        template<class U1, class U2>
        using base_unit_multiply = typename base_unit_multiply_impl<U1, U2>::type;

        template<class, class> struct base_unit_divide_impl;
        template<class... Exponents1, class... Exponents2>
        struct base_unit_divide_impl<base_unit<Exponents1...>, base_unit<Exponents2...>> {
            using type = base_unit<std::ratio_subtract<Exponents1, Exponents2>...>;
        };

        template<class U1, class U2>
        using base_unit_divide = typename base_unit_divide_impl<U1, U2>::type;

        template<class> struct inverse_base_impl;
 
        template<class... Exponents>
        struct inverse_base_impl<base_unit<Exponents...>> {
            using type = base_unit<std::ratio_multiply<Exponents, std::ratio<-1>>...>;
        };

        template<class U> using inverse_base = typename inverse_base_impl<U>::type;

        template<class U> struct squared_base_impl;
        template<class... Exponents>
        struct squared_base_impl<base_unit<Exponents...>> {
            using type = base_unit<std::ratio_multiply<Exponents, std::ratio<2>>...>;
        };

        template<class U> using squared_base = typename squared_base_impl<U>::type;

        template<class U> struct cubed_base_impl;
        template<class... Exponents>
        struct cubed_base_impl<base_unit<Exponents...>> {
            using type = base_unit<std::ratio_multiply<Exponents, std::ratio<3>>...>;
        };

        template<class U> using cubed_base = typename cubed_base_impl<U>::type;

        template<class U> struct sqrt_base_impl;
        template<class... Exponents>
        struct sqrt_base_impl<base_unit<Exponents...>> {
            using type = base_unit<std::ratio_divide<Exponents, std::ratio<2>>...>;
        };

        template<class U> using sqrt_base = typename sqrt_base_impl<U>::type;

        template<class U> struct cbrt_base_impl;
        template<class... Exponents>
        struct cbrt_base_impl<base_unit<Exponents...>> {
            using type = base_unit<std::ratio_divide<Exponents, std::ratio<3>>...>;
        };

        template<class U> using cbrt_base = typename cbrt_base_impl<U>::type;
    } // END DOXYGEN IGNORE
 
    //------------------------------
    //  UNIT MANIPULATORS
    //------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Unit1, class Unit2>
        struct unit_multiply_impl
        {
            using type = unit < std::ratio_multiply<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
                base_unit_multiply <traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
                std::ratio_add<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
                std::ratio < 0 >> ;
        };

        template<class U1, class U2>
        using unit_multiply = typename unit_multiply_impl<U1, U2>::type;

        template<class Unit1, class Unit2>
        struct unit_divide_impl
        {
            using type = unit < std::ratio_divide<typename Unit1::conversion_ratio, typename Unit2::conversion_ratio>,
                base_unit_divide<traits::base_unit_of<typename Unit1::base_unit_type>, traits::base_unit_of<typename Unit2::base_unit_type>>,
                std::ratio_subtract<typename Unit1::pi_exponent_ratio, typename Unit2::pi_exponent_ratio>,
                std::ratio < 0 >> ;
        };

        template<class U1, class U2>
        using unit_divide = typename unit_divide_impl<U1, U2>::type;

        template<class Unit>
        struct inverse_impl
        {
            using type = unit < std::ratio<Unit::conversion_ratio::den, Unit::conversion_ratio::num>,
                inverse_base<traits::base_unit_of<typename units::traits::unit_traits<Unit>::base_unit_type>>,
                std::ratio_multiply<typename units::traits::unit_traits<Unit>::pi_exponent_ratio, std::ratio<-1>>,
                std::ratio < 0 >> ; // inverses are rates or change, the translation factor goes away.
        };
    } // END DOXYGEN IGNORE

    template<class U> using inverse = typename units::detail::inverse_impl<U>::type;
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Unit>
        struct squared_impl
        {
            static_assert(traits::is_unit<Unit>::value, "Template parameter `Unit` must be a `unit` type.");
            using Conversion = typename Unit::conversion_ratio;
            using type = unit < std::ratio_multiply<Conversion, Conversion>,
                squared_base<traits::base_unit_of<typename Unit::base_unit_type>>,
                std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<2>>,
                typename Unit::translation_ratio
            > ;
        };
    } // END DOXYGEN IGNORE

    template<class U>
    using squared = typename units::detail::squared_impl<U>::type;
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Unit>
        struct cubed_impl
        {
            static_assert(traits::is_unit<Unit>::value, "Template parameter `Unit` must be a `unit` type.");
            using Conversion = typename Unit::conversion_ratio;
            using type = unit < std::ratio_multiply<Conversion, std::ratio_multiply<Conversion, Conversion>>,
                cubed_base<traits::base_unit_of<typename Unit::base_unit_type>>,
                std::ratio_multiply<typename Unit::pi_exponent_ratio, std::ratio<3>>,
                typename Unit::translation_ratio> ;
        };
    } // END DOXYGEN IGNORE

    template<class U>
    using cubed = typename units::detail::cubed_impl<U>::type;
    // DOXYGEN IGNORE
    namespace detail
    {
        //----------------------------------
        //  RATIO_SQRT IMPLEMENTATION
        //----------------------------------
 
        using Zero = std::ratio<0>;
        using One = std::ratio<1>;
        template <typename R> using Square = std::ratio_multiply<R, R>;
 
        // Find the largest std::integer N such that Predicate<N>::value is true.
        template <template <std::intmax_t N> class Predicate, typename enabled = void>
        struct BinarySearch {
            template <std::intmax_t N>
            struct SafeDouble_ {
                static constexpr const std::intmax_t value = 2 * N;
                static_assert(value > 0, "Overflows when computing 2 * N");
            };
 
            template <intmax_t Lower, intmax_t Upper, typename Condition1 = void, typename Condition2 = void>
            struct DoubleSidedSearch_ : DoubleSidedSearch_<Lower, Upper,
                std::integral_constant<bool, (Upper - Lower == 1)>,
                std::integral_constant<bool, ((Upper - Lower>1 && Predicate<Lower + (Upper - Lower) / 2>::value))>> {};
 
            template <intmax_t Lower, intmax_t Upper>
            struct DoubleSidedSearch_<Lower, Upper, std::false_type, std::false_type> : DoubleSidedSearch_<Lower, Lower + (Upper - Lower) / 2> {};
 
            template <intmax_t Lower, intmax_t Upper, typename Condition2>
            struct DoubleSidedSearch_<Lower, Upper, std::true_type, Condition2> : std::integral_constant<intmax_t, Lower>{};
 
            template <intmax_t Lower, intmax_t Upper, typename Condition1>
            struct DoubleSidedSearch_<Lower, Upper, Condition1, std::true_type> : DoubleSidedSearch_<Lower + (Upper - Lower) / 2, Upper>{};
 
            template <std::intmax_t Lower, class enabled1 = void>
            struct SingleSidedSearch_ : SingleSidedSearch_<Lower, std::integral_constant<bool, Predicate<SafeDouble_<Lower>::value>::value>>{};
 
            template <std::intmax_t Lower>
            struct SingleSidedSearch_<Lower, std::false_type> : DoubleSidedSearch_<Lower, SafeDouble_<Lower>::value> {};
 
            template <std::intmax_t Lower>
            struct SingleSidedSearch_<Lower, std::true_type> : SingleSidedSearch_<SafeDouble_<Lower>::value>{};
 
            static constexpr const std::intmax_t value = SingleSidedSearch_<1>::value;
        };
 
        template <template <std::intmax_t N> class Predicate>
        struct BinarySearch<Predicate, std::enable_if_t<!Predicate<1>::value>> : std::integral_constant<std::intmax_t, 0>{};
 
        // Find largest std::integer N such that N<=sqrt(R)
        template <typename R>
        struct Integer {
            template <std::intmax_t N> using Predicate_ = std::ratio_less_equal<std::ratio<N>, std::ratio_divide<R, std::ratio<N>>>;
            static constexpr const std::intmax_t value = BinarySearch<Predicate_>::value;
        };
 
        template <typename R>
        struct IsPerfectSquare {
            static constexpr const std::intmax_t DenSqrt_ = Integer<std::ratio<R::den>>::value;
            static constexpr const std::intmax_t NumSqrt_ = Integer<std::ratio<R::num>>::value;
            static constexpr const bool value =( DenSqrt_ * DenSqrt_ == R::den && NumSqrt_ * NumSqrt_ == R::num);
            using Sqrt = std::ratio<NumSqrt_, DenSqrt_>;
        };
 
        // Represents sqrt(P)-Q.
        template <typename Tp, typename Tq>
        struct Remainder {
            using P = Tp;
            using Q = Tq;
        };
 
        // Represents 1/R = I + Rem where R is a Remainder.
        template <typename R>
        struct Reciprocal {
            using P_ = typename R::P;
            using Q_ = typename R::Q;
            using Den_ = std::ratio_subtract<P_, Square<Q_>>;
            using A_ = std::ratio_divide<Q_, Den_>;
            using B_ = std::ratio_divide<P_, Square<Den_>>;
            static constexpr const std::intmax_t I_ = (A_::num + Integer<std::ratio_multiply<B_, Square<std::ratio<A_::den>>>>::value) / A_::den;
            using I = std::ratio<I_>;
            using Rem = Remainder<B_, std::ratio_subtract<I, A_>>;
        };
 
        // Expands sqrt(R) to continued fraction:
        // f(x)=C1+1/(C2+1/(C3+1/(...+1/(Cn+x)))) = (U*x+V)/(W*x+1) and sqrt(R)=f(Rem).
        // The error |f(Rem)-V| = |(U-W*V)x/(W*x+1)| <= |U-W*V|*Rem <= |U-W*V|/I' where
        // I' is the std::integer part of reciprocal of Rem.
        template <typename Tr, std::intmax_t N>
        struct ContinuedFraction {
            template <typename T>
            using Abs_ = std::conditional_t<std::ratio_less<T, Zero>::value, std::ratio_subtract<Zero, T>, T>;
 
            using R = Tr;
            using Last_ = ContinuedFraction<R, N - 1>;
            using Reciprocal_ = Reciprocal<typename Last_::Rem>;
            using Rem = typename Reciprocal_::Rem;
            using I_ = typename Reciprocal_::I;
            using Den_ = std::ratio_add<typename Last_::W, I_>;
            using U = std::ratio_divide<typename Last_::V, Den_>;
            using V = std::ratio_divide<std::ratio_add<typename Last_::U, std::ratio_multiply<typename Last_::V, I_>>, Den_>;
            using W = std::ratio_divide<One, Den_>;
            using Error = Abs_<std::ratio_divide<std::ratio_subtract<U, std::ratio_multiply<V, W>>, typename Reciprocal<Rem>::I>>;
        };
 
        template <typename Tr>
        struct ContinuedFraction<Tr, 1> {
            using R = Tr;
            using U = One;
            using V = std::ratio<Integer<R>::value>;
            using W = Zero;
            using Rem = Remainder<R, V>;
            using Error = std::ratio_divide<One, typename Reciprocal<Rem>::I>;
        };
 
        template <typename R, typename Eps, std::intmax_t N = 1, typename enabled = void>
        struct Sqrt_ : Sqrt_<R, Eps, N + 1> {};
 
        template <typename R, typename Eps, std::intmax_t N>
        struct Sqrt_<R, Eps, N, std::enable_if_t<std::ratio_less_equal<typename ContinuedFraction<R, N>::Error, Eps>::value>> {
            using type = typename ContinuedFraction<R, N>::V;
        };
 
        template <typename R, typename Eps, typename enabled = void>
        struct Sqrt {
            static_assert(std::ratio_greater_equal<R, Zero>::value, "R can't be negative");
        };
 
        template <typename R, typename Eps>
        struct Sqrt<R, Eps, std::enable_if_t<std::ratio_greater_equal<R, Zero>::value && IsPerfectSquare<R>::value>> {
            using type = typename IsPerfectSquare<R>::Sqrt;
        };
 
        template <typename R, typename Eps>
        struct Sqrt<R, Eps, std::enable_if_t<(std::ratio_greater_equal<R, Zero>::value && !IsPerfectSquare<R>::value)>> : Sqrt_<R, Eps>{};
    } // END DOXYGEN IGNORE

    template<typename Ratio, std::intmax_t Eps = 10000000000>
    using ratio_sqrt = typename  units::detail::Sqrt<Ratio, std::ratio<1, Eps>>::type;
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Unit, std::intmax_t Eps>
        struct sqrt_impl
        {
            static_assert(traits::is_unit<Unit>::value, "Template parameter `Unit` must be a `unit` type.");
            using Conversion = typename Unit::conversion_ratio;
            using type = unit <ratio_sqrt<Conversion, Eps>,
                sqrt_base<traits::base_unit_of<typename Unit::base_unit_type>>,
                std::ratio_divide<typename Unit::pi_exponent_ratio, std::ratio<2>>,
                typename Unit::translation_ratio>;
        };
    } // END DOXYGEN IGNORE

    template<class U, std::intmax_t Eps = 10000000000>
    using square_root = typename units::detail::sqrt_impl<U, Eps>::type;
 
    //------------------------------
    //  COMPOUND UNITS
    //------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class U, class... Us> struct compound_impl;
        template<class U> struct compound_impl<U> { using type = U; };
        template<class U1, class U2, class...Us>
        struct compound_impl<U1, U2, Us...>
            : compound_impl<unit_multiply<U1, U2>, Us...> {};
    } // END DOXYGEN IGNORE

    template<class U, class... Us>
    using compound_unit = typename units::detail::compound_impl<U, Us...>::type;
 
    //------------------------------
    //  PREFIXES
    //------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Ratio, class Unit>
        struct prefix
        {
            static_assert(traits::is_ratio<Ratio>::value, "Template parameter `Ratio` must be a `std::ratio`.");
            static_assert(traits::is_unit<Unit>::value, "Template parameter `Unit` must be a `unit` type.");
            typedef typename units::unit<Ratio, Unit> type;
        };

        template <int N, class U>
        struct power_of_ratio
        {
            typedef std::ratio_multiply<U, typename power_of_ratio<N - 1, U>::type> type;
        };

        template <class U>
        struct power_of_ratio<1, U>
        {
            typedef U type;
        };
    } // END DOXYGEN IGNORE

    template<class U> using atto    = typename units::detail::prefix<std::atto, U>::type;           
    template<class U> using femto  = typename units::detail::prefix<std::femto,U>::type;           
    template<class U> using pico    = typename units::detail::prefix<std::pico, U>::type;           
    template<class U> using nano    = typename units::detail::prefix<std::nano, U>::type;           
    template<class U> using micro  = typename units::detail::prefix<std::micro,U>::type;           
    template<class U> using milli  = typename units::detail::prefix<std::milli,U>::type;           
    template<class U> using centi  = typename units::detail::prefix<std::centi,U>::type;           
    template<class U> using deci    = typename units::detail::prefix<std::deci, U>::type;           
    template<class U> using deca    = typename units::detail::prefix<std::deca, U>::type;           
    template<class U> using hecto  = typename units::detail::prefix<std::hecto,U>::type;           
    template<class U> using kilo    = typename units::detail::prefix<std::kilo, U>::type;           
    template<class U> using mega    = typename units::detail::prefix<std::mega, U>::type;           
    template<class U> using giga    = typename units::detail::prefix<std::giga, U>::type;           
    template<class U> using tera    = typename units::detail::prefix<std::tera, U>::type;           
    template<class U> using peta    = typename units::detail::prefix<std::peta, U>::type;           
    template<class U> using exa      = typename units::detail::prefix<std::exa,  U>::type;           

    template<class U> using kibi    = typename units::detail::prefix<std::ratio<1024>,                  U>::type;   
    template<class U> using mebi    = typename units::detail::prefix<std::ratio<1048576>,               U>::type;   
    template<class U> using gibi    = typename units::detail::prefix<std::ratio<1073741824>,            U>::type;   
    template<class U> using tebi    = typename units::detail::prefix<std::ratio<1099511627776>,         U>::type;   
    template<class U> using pebi    = typename units::detail::prefix<std::ratio<1125899906842624>,      U>::type;   
    template<class U> using exbi    = typename units::detail::prefix<std::ratio<1152921504606846976>,   U>::type;   
 
    //------------------------------
    //  CONVERSION TRAITS
    //------------------------------
 
    namespace traits
    {
        template<class U1, class U2>
        struct is_convertible_unit : std::is_same <traits::base_unit_of<typename units::traits::unit_traits<U1>::base_unit_type>,
            base_unit_of<typename units::traits::unit_traits<U2>::base_unit_type >> {};
    }
 
    //------------------------------
    //  CONVERSION FUNCTION
    //------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        constexpr inline UNIT_LIB_DEFAULT_TYPE pow(UNIT_LIB_DEFAULT_TYPE x, unsigned long long y)
        {
            return y == 0 ? 1.0 : x * pow(x, y - 1);
        }
 
        constexpr inline UNIT_LIB_DEFAULT_TYPE abs(UNIT_LIB_DEFAULT_TYPE x)
        {
            return x < 0 ? -x : x;
        }

        template<class Ratio, class PiRatio, class Translation, bool piRequired, bool translationRequired, typename T>
        static inline constexpr T convert(const T& value, std::true_type, std::integral_constant<bool, piRequired>, std::integral_constant<bool, translationRequired>) noexcept
        {
            return value;
        }
 
        template<std::intmax_t  Ratio_num, std::intmax_t Ratio_den>
        struct normal_convert
        {
            template<typename T>
            inline constexpr T operator()(const T& value) const noexcept
            {
                return value * Ratio_num / Ratio_den;
            }
        };
 
        template<std::intmax_t  Ratio_num>
        struct normal_convert<Ratio_num, 1>
        {
            template<typename T>
            inline constexpr T operator()(const T& value) const noexcept
            {
                return value * Ratio_num;
            }
        };
 
        template<std::intmax_t  Ratio_den>
        struct normal_convert<1, Ratio_den>
        {
            template<typename T>
            inline constexpr T operator()(const T& value) const noexcept
            {
                return value / Ratio_den;
            }
        };
 
        template<>
        struct normal_convert<1, 1>
        {
            template<typename T>
            inline constexpr T operator()(const T& value) const noexcept
            {
                return value;
            }
        };

        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline constexpr T convert(const T& value, std::false_type, std::false_type, std::false_type) noexcept
        {
            return normal_convert<Ratio::num, Ratio::den>{}(value);
        }

        // constepxr with PI in numerator
        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline constexpr
        std::enable_if_t<(PiRatio::num / PiRatio::den >= 1 && PiRatio::num % PiRatio::den == 0), T>
        convert(const T& value, std::false_type, std::true_type, std::false_type) noexcept
        {
            return normal_convert<Ratio::num, Ratio::den>{}(value) * pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den);
        }

        // constexpr with PI in denominator
        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline constexpr
        std::enable_if_t<(PiRatio::num / PiRatio::den <= -1 && PiRatio::num % PiRatio::den == 0), T>
        convert(const T& value, std::false_type, std::true_type, std::false_type) noexcept
        {
            return normal_convert<Ratio::num, Ratio::den>{}(value) / pow(constants::detail::PI_VAL, -PiRatio::num / PiRatio::den);
        }

        // Not constexpr - uses std::pow
        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline // sorry, this can't be constexpr!
        std::enable_if_t<(PiRatio::num / PiRatio::den < 1 && PiRatio::num / PiRatio::den > -1), T>
        convert(const T& value, std::false_type, std::true_type, std::false_type) noexcept
        {
            return normal_convert<Ratio::num, Ratio::den>{}(value) * std::pow(constants::detail::PI_VAL, PiRatio::num / PiRatio::den);
        }

        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline constexpr T convert(const T& value, std::false_type, std::false_type, std::true_type) noexcept
        {
            return normal_convert<Ratio::num, Ratio::den>{}(value) + (static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
        }

        template<class Ratio, class PiRatio, class Translation, typename T>
        static inline constexpr T convert(const T& value, std::false_type isSame, std::true_type piRequired, std::true_type) noexcept
        {
            return convert<Ratio, PiRatio, Translation>(value, isSame, piRequired, std::false_type()) + (static_cast<UNIT_LIB_DEFAULT_TYPE>(Translation::num) / Translation::den);
        }
    } // END DOXYGEN IGNORE

    template<class UnitFrom, class UnitTo, typename T = UNIT_LIB_DEFAULT_TYPE>
    static inline constexpr T convert(const T& value) noexcept
    {
        static_assert(traits::is_unit<UnitFrom>::value, "Template parameter `UnitFrom` must be a `unit` type.");
        static_assert(traits::is_unit<UnitTo>::value, "Template parameter `UnitTo` must be a `unit` type.");
        static_assert(traits::is_convertible_unit<UnitFrom, UnitTo>::value, "Units are not compatible.");
 
        using Ratio = std::ratio_divide<typename UnitFrom::conversion_ratio, typename UnitTo::conversion_ratio>;
        using PiRatio = std::ratio_subtract<typename UnitFrom::pi_exponent_ratio, typename UnitTo::pi_exponent_ratio>;
        using Translation = std::ratio_divide<std::ratio_subtract<typename UnitFrom::translation_ratio, typename UnitTo::translation_ratio>, typename UnitTo::conversion_ratio>;
 
        using isSame = typename std::is_same<std::decay_t<UnitFrom>, std::decay_t<UnitTo>>::type;
        using piRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, PiRatio>::value)>;
        using translationRequired = std::integral_constant<bool, !(std::is_same<std::ratio<0>, Translation>::value)>;
 
        return units::detail::convert<Ratio, PiRatio, Translation>
            (value, isSame{}, piRequired{}, translationRequired{});
    }
 
    //----------------------------------
    //  NON-LINEAR SCALE TRAITS
    //----------------------------------
    // DOXYGEN IGNORE
    namespace traits
    {
        namespace detail
        {
            template<class T, class Ret>
            struct has_operator_parenthesis_impl
            {
                template<class U>
                static constexpr auto test(U*) -> decltype(std::declval<U>()()) { return decltype(std::declval<U>()()){}; }
                template<typename>
                static constexpr std::false_type test(...) { return std::false_type{}; }
 
                using type = typename std::is_same<Ret, decltype(test<T>(0))>::type;
            };
        }

        template<class T, class Ret>
        struct has_operator_parenthesis : traits::detail::has_operator_parenthesis_impl<T, Ret>::type {};
    }
 
    namespace traits
    {
        namespace detail
        {
            template<class T, class Ret>
            struct has_value_member_impl
            {
                template<class U>
                static constexpr auto test(U* p) -> decltype(p->m_value) { return p->m_value; }
                template<typename>
                static constexpr auto test(...)->std::false_type { return std::false_type{}; }
 
                using type = typename std::is_same<std::decay_t<Ret>, std::decay_t<decltype(test<T>(0))>>::type;
            };
        }

        template<class T, class Ret>
        struct has_value_member : traits::detail::has_value_member_impl<T, Ret>::type {};
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
        template<class T, class Ret>
        struct is_nonlinear_scale : std::integral_constant<bool,
            std::is_default_constructible<T>::value &&
            has_operator_parenthesis<T, Ret>::value &&
            has_value_member<T, Ret>::value &&
            std::is_trivial<T>::value>
        {};
    }
 
    //------------------------------
    //  UNIT_T TYPE TRAITS
    //------------------------------
 
    namespace traits
    {
#ifdef FOR_DOXYGEN_PURPOSOES_ONLY
        template<typename T>
        struct unit_t_traits
        {
            typedef typename T::non_linear_scale_type non_linear_scale_type;    
            typedef typename T::underlying_type underlying_type;                
            typedef typename T::value_type value_type;                          
            typedef typename T::unit_type unit_type;                            
        };
#endif
    // DOXYGEN IGNORE
        template<typename T, typename = void>
        struct unit_t_traits
        {
            typedef void non_linear_scale_type;
            typedef void underlying_type;
            typedef void value_type;
            typedef void unit_type;
        };

        template<typename T>
        struct unit_t_traits <T, typename void_t<
            typename T::non_linear_scale_type,
            typename T::underlying_type,
            typename T::value_type,
            typename T::unit_type>::type>
        {
            typedef typename T::non_linear_scale_type non_linear_scale_type;
            typedef typename T::underlying_type underlying_type;
            typedef typename T::value_type value_type;
            typedef typename T::unit_type unit_type;
        }; // END DOXYGEN IGNORE
    }
 
    namespace traits
    {
        template<class U1, class U2>
        struct is_convertible_unit_t : std::integral_constant<bool,
            is_convertible_unit<typename units::traits::unit_t_traits<U1>::unit_type, typename units::traits::unit_t_traits<U2>::unit_type>::value>
        {};
    }
 
    //----------------------------------
    //  UNIT TYPE
    //----------------------------------
    // DOXYGEN IGNORE
    // forward declaration
    template<typename T> struct linear_scale;
    template<typename T> struct decibel_scale;
 
    namespace detail
    {
        struct _unit_t {};
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
        // forward declaration
        #if !defined(_MSC_VER) || _MSC_VER > 1800 // bug in VS2013 prevents this from working
        template<typename... T> struct is_dimensionless_unit;
        #else
        template<typename T1, typename T2 = T1, typename T3 = T1> struct is_dimensionless_unit;
        #endif

        template<class T>
        struct is_unit_t : std::is_base_of<units::detail::_unit_t, T>::type {};
    }

    template<class Units, typename T = UNIT_LIB_DEFAULT_TYPE, template<typename> class NonLinearScale = linear_scale>
    class unit_t : public NonLinearScale<T>, units::detail::_unit_t
    {
        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).");
        static_assert(traits::is_nonlinear_scale<NonLinearScale<T>, T>::value, "Template parameter `NonLinearScale` does not conform to the `is_nonlinear_scale` concept.");
 
    protected:
 
        using nls = NonLinearScale<T>;
        using nls::m_value;
 
    public:
 
        typedef NonLinearScale<T> non_linear_scale_type;                                           
        typedef T underlying_type;                                                                   
        typedef T value_type;                                                                     
        typedef Units unit_type;                                                                   

        constexpr unit_t() = default;

        template<class... Args>
        inline explicit constexpr unit_t(const T value, const Args&... args) noexcept : nls(value, args...)
        {
 
        }

        template<class Ty, class = typename std::enable_if<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>::type>
        inline constexpr unit_t(const Ty value) noexcept : nls(value)
        {
 
        }

        template<class Rep, class Period, class = std::enable_if_t<std::is_arithmetic<Rep>::value && traits::is_ratio<Period>::value>>
        inline constexpr unit_t(const std::chrono::duration<Rep, Period>& value) noexcept :
        nls(units::convert<unit<std::ratio<1,1000000000>, category::time_unit>, Units>(static_cast<T>(std::chrono::duration_cast<std::chrono::nanoseconds>(value).count())))
        {
 
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr unit_t(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) noexcept :
        nls(units::convert<UnitsRhs, Units, T>(rhs.m_value), std::true_type() /*store linear value*/)
        {
 
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline unit_t& operator=(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) noexcept
        {
            nls::m_value = units::convert<UnitsRhs, Units, T>(rhs.m_value);
            return *this;
        }

        template<class Ty, class = std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value>>
        inline unit_t& operator=(const Ty& rhs) noexcept
        {
            nls::m_value = rhs;
            return *this;
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr bool operator<(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return (nls::m_value < units::convert<UnitsRhs, Units>(rhs.m_value));
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr bool operator<=(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return (nls::m_value <= units::convert<UnitsRhs, Units>(rhs.m_value));
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr bool operator>(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return (nls::m_value > units::convert<UnitsRhs, Units>(rhs.m_value));
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr bool operator>=(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return (nls::m_value >= units::convert<UnitsRhs, Units>(rhs.m_value));
        }

        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>
        inline constexpr bool operator==(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return detail::abs(nls::m_value - units::convert<UnitsRhs, Units>(rhs.m_value)) < std::numeric_limits<T>::epsilon() *
                detail::abs(nls::m_value + units::convert<UnitsRhs, Units>(rhs.m_value)) ||
                detail::abs(nls::m_value - units::convert<UnitsRhs, Units>(rhs.m_value)) < std::numeric_limits<T>::min();
        }
 
        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>
        inline constexpr bool operator==(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return nls::m_value == units::convert<UnitsRhs, Units>(rhs.m_value);
        }

        template<class UnitsRhs, typename Ty, template<typename> class NlsRhs>
        inline constexpr bool operator!=(const unit_t<UnitsRhs, Ty, NlsRhs>& rhs) const noexcept
        {
            return !(*this == rhs);
        }

        inline constexpr underlying_type value() const noexcept
        {
            return static_cast<underlying_type>(*this);
        }

        template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
        inline constexpr Ty to() const noexcept
        {
            return static_cast<Ty>(*this);
        }

        template<typename Ty, class = std::enable_if_t<std::is_arithmetic<Ty>::value>>
        inline constexpr Ty toLinearized() const noexcept
        {
            return static_cast<Ty>(m_value);
        }

        template<class U>
        inline constexpr unit_t<U> convert() const noexcept
        {
            static_assert(traits::is_unit<U>::value, "Template parameter `U` must be a unit type.");
            return unit_t<U>(*this);
        }

        template<class Ty, std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value, int> = 0>
        inline constexpr operator Ty() const noexcept
        {
            // this conversion also resolves any PI exponents, by converting from a non-zero PI ratio to a zero-pi ratio.
            return static_cast<Ty>(units::convert<Units, unit<std::ratio<1>, units::category::scalar_unit>>((*this)()));
        }

        template<class Ty, std::enable_if_t<!traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value, int> = 0>
        inline constexpr explicit operator Ty() const noexcept
        {
            return static_cast<Ty>((*this)());
        }

        template<typename U = Units, std::enable_if_t<units::traits::is_convertible_unit<U, unit<std::ratio<1>, category::time_unit>>::value, int> = 0>
        inline constexpr operator std::chrono::nanoseconds() const noexcept
        {
            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)())));
        }

        inline constexpr const char* name() const noexcept
        {
            return units::name(*this);
        }

        inline constexpr const char* abbreviation() const noexcept
        {
            return units::abbreviation(*this);
        }
 
    public:
 
        template<class U, typename Ty, template<typename> class Nlt>
        friend class unit_t;
    };
 
    //------------------------------
    //  UNIT_T NON-MEMBER FUNCTIONS
    //------------------------------

    template<class UnitType, typename T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
    inline constexpr UnitType make_unit(const T value) noexcept
    {
        static_assert(traits::is_unit_t<UnitType>::value, "Template parameter `UnitType` must be a unit type (_t).");
 
        return UnitType(value);
    }
 
#if !defined(UNIT_LIB_DISABLE_IOSTREAM)
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline std::ostream& operator<<(std::ostream& os, const unit_t<Units, T, NonLinearScale>& obj) noexcept
    {
        using BaseUnits = unit<std::ratio<1>, typename traits::unit_traits<Units>::base_unit_type>;
        os << convert<Units, BaseUnits>(obj());
 
        if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0) { os << " m"; }
        if (traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::meter_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::meter_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::meter_ratio::den != 1) { os << "/"   << traits::unit_traits<Units>::base_unit_type::meter_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0) { os << " kg"; }
        if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::kilogram_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0) { os << " s"; }
        if (traits::unit_traits<Units>::base_unit_type::second_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::second_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::second_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::second_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::second_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0) { os << " A"; }
        if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::ampere_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::ampere_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::ampere_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0) { os << " K"; }
        if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::kelvin_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0) { os << " mol"; }
        if (traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::mole_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::mole_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::mole_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::mole_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0) { os << " cd"; }
        if (traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::candela_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::candela_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::candela_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::candela_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0) { os << " rad"; }
        if (traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::radian_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::radian_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::radian_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::radian_ratio::den; }
 
        if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0) { os << " b"; }
        if (traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 0 &&
            traits::unit_traits<Units>::base_unit_type::byte_ratio::num != 1) { os << "^" << traits::unit_traits<Units>::base_unit_type::byte_ratio::num; }
        if (traits::unit_traits<Units>::base_unit_type::byte_ratio::den != 1) { os << "/" << traits::unit_traits<Units>::base_unit_type::byte_ratio::den; }
 
        return os;
    }
#endif
 
    template<class Units, typename T, template<typename> class NonLinearScale, typename RhsType>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator+=(unit_t<Units, T, NonLinearScale>& lhs, const RhsType& rhs) noexcept
    {
        static_assert(traits::is_convertible_unit_t<unit_t<Units, T, NonLinearScale>, RhsType>::value ||
            (traits::is_dimensionless_unit<decltype(lhs)>::value && std::is_arithmetic<RhsType>::value),
            "parameters are not compatible units.");
 
        lhs = lhs + rhs;
        return lhs;
    }
 
    template<class Units, typename T, template<typename> class NonLinearScale, typename RhsType>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator-=(unit_t<Units, T, NonLinearScale>& lhs, const RhsType& rhs) noexcept
    {
        static_assert(traits::is_convertible_unit_t<unit_t<Units, T, NonLinearScale>, RhsType>::value ||
            (traits::is_dimensionless_unit<decltype(lhs)>::value && std::is_arithmetic<RhsType>::value),
            "parameters are not compatible units.");
 
        lhs = lhs - rhs;
        return lhs;
    }
 
    template<class Units, typename T, template<typename> class NonLinearScale, typename RhsType>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator*=(unit_t<Units, T, NonLinearScale>& lhs, const RhsType& rhs) noexcept
    {
        static_assert((traits::is_dimensionless_unit<RhsType>::value || std::is_arithmetic<RhsType>::value),
            "right-hand side parameter must be dimensionless.");
 
        lhs = lhs * rhs;
        return lhs;
    }
 
    template<class Units, typename T, template<typename> class NonLinearScale, typename RhsType>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator/=(unit_t<Units, T, NonLinearScale>& lhs, const RhsType& rhs) noexcept
    {
        static_assert((traits::is_dimensionless_unit<RhsType>::value || std::is_arithmetic<RhsType>::value),
            "right-hand side parameter must be dimensionless.");
 
        lhs = lhs / rhs;
        return lhs;
    }
 
    //------------------------------
    //  UNIT_T UNARY OPERATORS
    //------------------------------
 
    // unary addition: +T
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale> operator+(const unit_t<Units, T, NonLinearScale>& u) noexcept
    {
        return u;
    }
 
    // prefix increment: ++T
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator++(unit_t<Units, T, NonLinearScale>& u) noexcept
    {
        u = unit_t<Units, T, NonLinearScale>(u() + 1);
        return u;
    }
 
    // postfix increment: T++
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale> operator++(unit_t<Units, T, NonLinearScale>& u, int) noexcept
    {
        auto ret = u;
        u = unit_t<Units, T, NonLinearScale>(u() + 1);
        return ret;
    }
 
    // unary addition: -T
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale> operator-(const unit_t<Units, T, NonLinearScale>& u) noexcept
    {
        return unit_t<Units, T, NonLinearScale>(-u());
    }
 
    // prefix increment: --T
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale>& operator--(unit_t<Units, T, NonLinearScale>& u) noexcept
    {
        u = unit_t<Units, T, NonLinearScale>(u() - 1);
        return u;
    }
 
    // postfix increment: T--
    template<class Units, typename T, template<typename> class NonLinearScale>
    inline constexpr unit_t<Units, T, NonLinearScale> operator--(unit_t<Units, T, NonLinearScale>& u, int) noexcept
    {
        auto ret = u;
        u = unit_t<Units, T, NonLinearScale>(u() - 1);
        return ret;
    }
 
    //------------------------------
    //  UNIT_CAST
    //------------------------------

    template<typename T, typename Units, class = std::enable_if_t<std::is_arithmetic<T>::value && traits::is_unit_t<Units>::value>>
    inline constexpr T unit_cast(const Units& value) noexcept
    {
        return static_cast<T>(value);
    }
 
    //------------------------------
    //  NON-LINEAR SCALE TRAITS
    //------------------------------
 
    // forward declaration
    template<typename T> struct decibel_scale;
 
    namespace traits
    {
#if !defined(_MSC_VER) || _MSC_VER > 1800   // bug in VS2013 prevents this from working
        template<typename... T>
        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 > {};
#else
        template<typename T1, typename T2 = T1, typename T3 = T1>
        struct has_linear_scale : std::integral_constant<bool,
            std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
            std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
            std::is_base_of<units::linear_scale<typename units::traits::unit_t_traits<T3>::underlying_type>, T3>::value> {};
#endif

#if !defined(_MSC_VER) || _MSC_VER > 1800   // bug in VS2013 prevents this from working
        template<typename... T>
        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> {};
#else
        template<typename T1, typename T2 = T1, typename T3 = T1>
        struct has_decibel_scale : std::integral_constant<bool,
            std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T1>::underlying_type>, T1>::value &&
            std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T2>::value &&
            std::is_base_of<units::decibel_scale<typename units::traits::unit_t_traits<T2>::underlying_type>, T3>::value> {};
#endif

        template<typename T1, typename T2>
        struct is_same_scale : std::integral_constant<bool,
            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>
        {};
    }
 
    //----------------------------------
    //  NON-LINEAR SCALES
    //----------------------------------
 
    // Non-linear transforms are used to pre and post scale units which are defined in terms of non-
    // linear functions of their current value. A good example of a non-linear scale would be a
    // logarithmic or decibel scale
 
    //------------------------------
    //  LINEAR SCALE
    //------------------------------

    template<typename T>
    struct linear_scale
    {
        inline constexpr linear_scale() = default;                                                  
        inline constexpr linear_scale(const linear_scale&) = default;
        inline ~linear_scale() = default;
        inline linear_scale& operator=(const linear_scale&) = default;
#if defined(_MSC_VER) && (_MSC_VER > 1800)
        inline constexpr linear_scale(linear_scale&&) = default;
        inline linear_scale& operator=(linear_scale&&) = default;
#endif
        template<class... Args>
        inline constexpr linear_scale(const T& value, Args&&...) noexcept : m_value(value) {}    
        inline constexpr T operator()() const noexcept { return m_value; }                         
 
        T m_value;                                                                                   
    };
 
    //----------------------------------
    //  SCALAR (LINEAR) UNITS
    //----------------------------------
 
    // Scalar units are the *ONLY* units implicitly convertible to/from built-in types.
    namespace dimensionless
    {
        typedef unit<std::ratio<1>, units::category::scalar_unit> scalar;
        typedef unit<std::ratio<1>, units::category::dimensionless_unit> dimensionless;
 
        typedef unit_t<scalar> scalar_t;
        typedef scalar_t dimensionless_t;
    }
 
// ignore the redeclaration of the default template parameters
#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4348)
#endif
    UNIT_ADD_CATEGORY_TRAIT(scalar)
    UNIT_ADD_CATEGORY_TRAIT(dimensionless)
#if defined(_MSC_VER)
#   pragma warning(pop)
#endif
 
    //------------------------------
    //  LINEAR ARITHMETIC
    //------------------------------
 
    template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<!traits::is_same_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
    constexpr inline int operator+(const UnitTypeLhs& /* lhs */, const UnitTypeRhs& /* rhs */) noexcept
    {
        static_assert(traits::is_same_scale<UnitTypeLhs, UnitTypeRhs>::value, "Cannot add units with different linear/non-linear scales.");
        return 0;
    }

    template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
    inline constexpr UnitTypeLhs operator+(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return UnitTypeLhs(lhs() + convert<UnitsRhs, UnitsLhs>(rhs()));
    }

    template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
    inline constexpr dimensionless::scalar_t operator+(const dimensionless::scalar_t& lhs, T rhs) noexcept
    {
        return dimensionless::scalar_t(lhs() + rhs);
    }

    template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
    inline constexpr dimensionless::scalar_t operator+(T lhs, const dimensionless::scalar_t& rhs) noexcept
    {
        return dimensionless::scalar_t(lhs + rhs());
    }

    template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
    inline constexpr UnitTypeLhs operator-(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return UnitTypeLhs(lhs() - convert<UnitsRhs, UnitsLhs>(rhs()));
    }

    template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
    inline constexpr dimensionless::scalar_t operator-(const dimensionless::scalar_t& lhs, T rhs) noexcept
    {
        return dimensionless::scalar_t(lhs() - rhs);
    }

    template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
    inline constexpr dimensionless::scalar_t operator-(T lhs, const dimensionless::scalar_t& rhs) noexcept
    {
        return dimensionless::scalar_t(lhs - rhs());
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
        inline constexpr auto operator*(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<compound_unit<squared<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>>>
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return  unit_t<compound_unit<squared<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>>>
            (lhs() * convert<UnitsRhs, UnitsLhs>(rhs()));
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        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>
        inline constexpr auto operator*(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<compound_unit<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type, typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return unit_t<compound_unit<UnitsLhs, UnitsRhs>>
            (lhs() * rhs());
    }

    template<class UnitTypeLhs, typename UnitTypeRhs,
        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>
        inline constexpr UnitTypeLhs operator*(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        // the cast makes sure factors of PI are handled as expected
        return UnitTypeLhs(lhs() * static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs));
    }

    template<class UnitTypeLhs, typename UnitTypeRhs,
        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>
        inline constexpr UnitTypeRhs operator*(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        // the cast makes sure factors of PI are handled as expected
        return UnitTypeRhs(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) * rhs());
    }

    template<class UnitTypeLhs, typename T,
        std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value, int> = 0>
        inline constexpr UnitTypeLhs operator*(const UnitTypeLhs& lhs, T rhs) noexcept
    {
        return UnitTypeLhs(lhs() * rhs);
    }

    template<class UnitTypeRhs, typename T,
        std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value, int> = 0>
        inline constexpr UnitTypeRhs operator*(T lhs, const UnitTypeRhs& rhs) noexcept
    {
        return UnitTypeRhs(lhs * rhs());
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        std::enable_if_t<traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value && traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
        inline constexpr dimensionless::scalar_t operator/(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return dimensionless::scalar_t(lhs() / convert<UnitsRhs, UnitsLhs>(rhs()));
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        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>
        inline constexpr auto operator/(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept ->  unit_t<compound_unit<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type, inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>>
    {
        using UnitsLhs = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return unit_t<compound_unit<UnitsLhs, inverse<UnitsRhs>>>
            (lhs() / rhs());
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        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>
        inline constexpr UnitTypeLhs operator/(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept
    {
        return UnitTypeLhs(lhs() / static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs));
    }

    template<class UnitTypeLhs, class UnitTypeRhs,
        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>
        inline constexpr auto operator/(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>
    {
        return unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>
            (static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) / rhs());
    }

    template<class UnitTypeLhs, typename T,
        std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeLhs>::value, int> = 0>
        inline constexpr UnitTypeLhs operator/(const UnitTypeLhs& lhs, T rhs) noexcept
    {
        return UnitTypeLhs(lhs() / rhs);
    }

    template<class UnitTypeRhs, typename T,
        std::enable_if_t<std::is_arithmetic<T>::value && traits::has_linear_scale<UnitTypeRhs>::value, int> = 0>
        inline constexpr auto operator/(T lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>
    {
        using UnitsRhs = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        return unit_t<inverse<UnitsRhs>>
            (lhs / rhs());
    }
 
    //----------------------------------
    //  SCALAR COMPARISONS
    //----------------------------------
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator==(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return detail::abs(lhs - static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs)) < std::numeric_limits<UNIT_LIB_DEFAULT_TYPE>::epsilon() * detail::abs(lhs + static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs)) ||
            detail::abs(lhs - static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs)) < std::numeric_limits<UNIT_LIB_DEFAULT_TYPE>::min();
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator==(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return detail::abs(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) - rhs) < std::numeric_limits<UNIT_LIB_DEFAULT_TYPE>::epsilon() * detail::abs(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) + rhs) ||
            detail::abs(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) - rhs) < std::numeric_limits<UNIT_LIB_DEFAULT_TYPE>::min();
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator!=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return!(lhs == static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs));
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator!=(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return !(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) == rhs);
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator>=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return std::isgreaterequal(lhs, static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs));
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator>=(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return std::isgreaterequal(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs), rhs);
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator>(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return lhs > static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs);
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator>(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) > rhs;
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator<=(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return std::islessequal(lhs, static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs));
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator<=(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return std::islessequal(static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs), rhs);
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator<(const UNIT_LIB_DEFAULT_TYPE lhs, const Units& rhs) noexcept
    {
        return lhs < static_cast<UNIT_LIB_DEFAULT_TYPE>(rhs);
    }
 
    template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
    constexpr bool operator<(const Units& lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
    {
        return static_cast<UNIT_LIB_DEFAULT_TYPE>(lhs) < rhs;
    }
 
    //----------------------------------
    //  POW
    //----------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template <int N, class U> struct power_of_unit
        {
            template<bool isPos, int V> struct power_of_unit_impl;
 
            template<int V> struct power_of_unit_impl<true, V>
            {
                typedef units::detail::unit_multiply<U, typename power_of_unit<N - 1, U>::type> type;
            };
 
            template<int V> struct power_of_unit_impl<false, V>
            {
                typedef units::inverse<typename power_of_unit<-N, U>::type> type;
            };
 
            typedef typename power_of_unit_impl<(N > 0), N>::type type;
        };

        template <class U> struct power_of_unit<1, U>
        {
            typedef U type;
        };
        template <class U> struct power_of_unit<0, U>
        {
            typedef units::dimensionless::dimensionless type;
        };
    } // END DOXYGEN IGNORE
 
    namespace math
    {
        template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value, int>>
        inline 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>
        {
            return 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>
                (std::pow(value(), power));
        }

        template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value, int>>
        inline 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>
        {
            static_assert(power >= 0, "cpow cannot accept negative numbers. Try units::math::pow instead.");
            return 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>
                (detail::pow(value(), power));
        }
    }
 
    //------------------------------
    //  DECIBEL SCALE
    //------------------------------

    template<typename T>
    struct decibel_scale
    {
        inline constexpr decibel_scale() = default;
        inline constexpr decibel_scale(const decibel_scale&) = default;
        inline ~decibel_scale() = default;
        inline decibel_scale& operator=(const decibel_scale&) = default;
#if defined(_MSC_VER) && (_MSC_VER > 1800)
        inline constexpr decibel_scale(decibel_scale&&) = default;
        inline decibel_scale& operator=(decibel_scale&&) = default;
#endif
        inline constexpr decibel_scale(const T value) noexcept : m_value(std::pow(10, value / 10)) {}
        template<class... Args>
        inline constexpr decibel_scale(const T value, std::true_type, Args&&...) noexcept : m_value(value) {}
        inline constexpr T operator()() const noexcept { return 10 * std::log10(m_value); }
 
        T m_value;   
    };
 
    //------------------------------
    //  SCALAR (DECIBEL) UNITS
    //------------------------------

    namespace dimensionless
    {
        typedef unit_t<scalar, UNIT_LIB_DEFAULT_TYPE, decibel_scale> dB_t;
#if !defined(UNIT_LIB_DISABLE_IOSTREAM)
        inline std::ostream& operator<<(std::ostream& os, const dB_t& obj) { os << obj() << " dB"; return os; }
#endif
        typedef dB_t dBi_t;
    }
 
    //------------------------------
    //  DECIBEL ARITHMETIC
    //------------------------------

    template<class UnitTypeLhs, class UnitTypeRhs,
        std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
    constexpr inline auto operator+(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<compound_unit<squared<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>>, typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type, decibel_scale>
    {
        using LhsUnits = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using RhsUnits = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        using underlying_type = typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
 
        return unit_t<compound_unit<squared<LhsUnits>>, underlying_type, decibel_scale>
            (lhs.template toLinearized<underlying_type>() * convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
    }

    template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value, int> = 0>
    constexpr inline UnitTypeLhs operator+(const UnitTypeLhs& lhs, const dimensionless::dB_t& rhs) noexcept
    {
        using underlying_type = typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
        return UnitTypeLhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
    }

    template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value, int> = 0>
    constexpr inline UnitTypeRhs operator+(const dimensionless::dB_t& lhs, const UnitTypeRhs& rhs) noexcept
    {
        using underlying_type = typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type;
        return UnitTypeRhs(lhs.template toLinearized<underlying_type>() * rhs.template toLinearized<underlying_type>(), std::true_type());
    }

    template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
    constexpr inline auto operator-(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<compound_unit<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type, inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>, typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type, decibel_scale>
    {
        using LhsUnits = typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type;
        using RhsUnits = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        using underlying_type = typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
 
        return unit_t<compound_unit<LhsUnits, inverse<RhsUnits>>, underlying_type, decibel_scale>
            (lhs.template toLinearized<underlying_type>() / convert<RhsUnits, LhsUnits>(rhs.template toLinearized<underlying_type>()), std::true_type());
    }

    template<class UnitTypeLhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeLhs>::value && !traits::is_dimensionless_unit<UnitTypeLhs>::value, int> = 0>
    constexpr inline UnitTypeLhs operator-(const UnitTypeLhs& lhs, const dimensionless::dB_t& rhs) noexcept
    {
        using underlying_type = typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type;
        return UnitTypeLhs(lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
    }

    template<class UnitTypeRhs, std::enable_if_t<traits::has_decibel_scale<UnitTypeRhs>::value && !traits::is_dimensionless_unit<UnitTypeRhs>::value, int> = 0>
    constexpr inline auto operator-(const dimensionless::dB_t& lhs, const UnitTypeRhs& rhs) noexcept -> unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>, typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type, decibel_scale>
    {
        using RhsUnits = typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type;
        using underlying_type = typename units::traits::unit_t_traits<RhsUnits>::underlying_type;
 
        return unit_t<inverse<RhsUnits>, underlying_type, decibel_scale>
            (lhs.template toLinearized<underlying_type>() / rhs.template toLinearized<underlying_type>(), std::true_type());
    }
 
    //----------------------------------
    //  UNIT RATIO CLASS
    //----------------------------------
    // DOXYGEN IGNORE
    namespace detail
    {
        template<class Units>
        struct _unit_value_t {};
    } // END DOXYGEN IGNORE
 
    namespace traits
    {
#ifdef FOR_DOXYGEN_PURPOSES_ONLY
        template<typename T>
        struct unit_value_t_traits
        {
            typedef typename T::unit_type unit_type;    
            typedef typename T::ratio ratio;            
        };
#endif
    // DOXYGEN IGNORE
        template<typename T, typename = void>
        struct unit_value_t_traits
        {
            typedef void unit_type;
            typedef void ratio;
        };

        template<typename T>
        struct unit_value_t_traits <T, typename void_t<
            typename T::unit_type,
            typename T::ratio>::type>
        {
            typedef typename T::unit_type unit_type;
            typedef typename T::ratio ratio;
        }; // END DOXYGEN IGNORE
    }
 
    //------------------------------------------------------------------------------
    //  COMPILE-TIME UNIT VALUES AND ARITHMETIC
    //------------------------------------------------------------------------------

    template<typename Units, std::uintmax_t Num, std::uintmax_t Denom = 1>
    struct unit_value_t : units::detail::_unit_value_t<Units>
    {
        typedef Units unit_type;
        typedef std::ratio<Num, Denom> ratio;
 
        static_assert(traits::is_unit<Units>::value, "Template parameter `Units` must be a unit type.");
        static constexpr const unit_t<Units> value() { return unit_t<Units>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den); }
    };
 
    namespace traits
    {
        template<typename T, typename Units = typename traits::unit_value_t_traits<T>::unit_type>
        struct is_unit_value_t : std::integral_constant<bool,
            std::is_base_of<units::detail::_unit_value_t<Units>, T>::value>
        {};

        template<typename Category, typename T>
        struct is_unit_value_t_category : std::integral_constant<bool,
            std::is_same<units::traits::base_unit_of<typename traits::unit_value_t_traits<T>::unit_type>, Category>::value>
        {
            static_assert(is_base_unit<Category>::value, "Template parameter `Category` must be a `base_unit` type.");
        };
    }
    // DOXYGEN IGNORE
    namespace detail
    {
        // base class for common arithmetic
        template<class U1, class U2>
        struct unit_value_arithmetic
        {
            static_assert(traits::is_unit_value_t<U1>::value, "Template parameter `U1` must be a `unit_value_t` type.");
            static_assert(traits::is_unit_value_t<U2>::value, "Template parameter `U2` must be a `unit_value_t` type.");
 
            using _UNIT1 = typename traits::unit_value_t_traits<U1>::unit_type;
            using _UNIT2 = typename traits::unit_value_t_traits<U2>::unit_type;
            using _CONV1 = typename units::traits::unit_traits<_UNIT1>::conversion_ratio;
            using _CONV2 = typename units::traits::unit_traits<_UNIT2>::conversion_ratio;
            using _RATIO1 = typename traits::unit_value_t_traits<U1>::ratio;
            using _RATIO2 = typename traits::unit_value_t_traits<U2>::ratio;
            using _RATIO2CONV = typename std::ratio_divide<std::ratio_multiply<_RATIO2, _CONV2>, _CONV1>;
            using _PI_EXP = std::ratio_subtract<typename units::traits::unit_traits<_UNIT2>::pi_exponent_ratio, typename units::traits::unit_traits<_UNIT1>::pi_exponent_ratio>;
        };
    } // END DOXYGEN IGNORE

    template<class U1, class U2>
    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>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U2>;
        typedef typename Base::_UNIT1 unit_type;
        using ratio = std::ratio_add<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
 
        static_assert(traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, "Unit types are not compatible."); // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)Base::_RATIO1::num / Base::_RATIO1::den) +
            ((UNIT_LIB_DEFAULT_TYPE)Base::_RATIO2CONV::num / Base::_RATIO2CONV::den) * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)Base::_PI_EXP::num / Base::_PI_EXP::den)));
        } // END DOXYGEN IGNORE
    };

    template<class U1, class U2>
    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>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U2>;
 
        typedef typename Base::_UNIT1 unit_type;
        using ratio = std::ratio_subtract<typename Base::_RATIO1, typename Base::_RATIO2CONV>;
 
        static_assert(traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, "Unit types are not compatible."); // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)Base::_RATIO1::num / Base::_RATIO1::den) - ((UNIT_LIB_DEFAULT_TYPE)Base::_RATIO2CONV::num / Base::_RATIO2CONV::den)
                * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)Base::_PI_EXP::num / Base::_PI_EXP::den)));
        } // END DOXYGEN IGNORE   };
    };

    template<class U1, class U2>
    struct unit_value_multiply : units::detail::unit_value_arithmetic<U1, U2>,
        units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
            typename traits::unit_value_t_traits<U2>::unit_type>::value, compound_unit<squared<typename traits::unit_value_t_traits<U1>::unit_type>>,
            compound_unit<typename traits::unit_value_t_traits<U1>::unit_type, typename traits::unit_value_t_traits<U2>::unit_type>>::type>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U2>;
 
        using unit_type = std::conditional_t<traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, compound_unit<squared<typename Base::_UNIT1>>, compound_unit<typename Base::_UNIT1, typename Base::_UNIT2>>;
        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>>; // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den) * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)Base::_PI_EXP::num / Base::_PI_EXP::den)));
        } // END DOXYGEN IGNORE
    };

    template<class U1, class U2>
    struct unit_value_divide : units::detail::unit_value_arithmetic<U1, U2>,
        units::detail::_unit_value_t<typename std::conditional<traits::is_convertible_unit<typename traits::unit_value_t_traits<U1>::unit_type,
        typename traits::unit_value_t_traits<U2>::unit_type>::value, dimensionless::scalar, compound_unit<typename traits::unit_value_t_traits<U1>::unit_type,
        inverse<typename traits::unit_value_t_traits<U2>::unit_type>>>::type>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U2>;
 
        using unit_type = std::conditional_t<traits::is_convertible_unit<typename Base::_UNIT1, typename Base::_UNIT2>::value, dimensionless::scalar, compound_unit<typename Base::_UNIT1, inverse<typename Base::_UNIT2>>>;
        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>>; // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den) * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)Base::_PI_EXP::num / Base::_PI_EXP::den)));
        } // END DOXYGEN IGNORE
    };

    template<class U1, int power>
    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>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U1>;
 
        using unit_type = typename units::detail::power_of_unit<power, typename Base::_UNIT1>::type;
        using ratio = typename units::detail::power_of_ratio<power, typename Base::_RATIO1>::type;
        using pi_exponent = std::ratio_multiply<std::ratio<power>, typename Base::_UNIT1::pi_exponent_ratio>; // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den) * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)pi_exponent::num / pi_exponent::den)));
        } // END DOXYGEN IGNORE   };
    };

    template<class U1, std::intmax_t Eps = 10000000000>
    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>>
    {    // DOXYGEN IGNORE
        using Base = units::detail::unit_value_arithmetic<U1, U1>;
 
        using unit_type = square_root<typename Base::_UNIT1, Eps>;
        using ratio = ratio_sqrt<typename Base::_RATIO1, Eps>;
        using pi_exponent = ratio_sqrt<typename Base::_UNIT1::pi_exponent_ratio, Eps>; // END DOXYGEN IGNORE

        static constexpr const unit_t<unit_type> value() noexcept
        {
            using UsePi = std::integral_constant<bool, Base::_PI_EXP::num != 0>;
            return value(UsePi());
        }
    // DOXYGEN IGNORE
        // value if PI isn't involved
        static constexpr const unit_t<unit_type> value(std::false_type) noexcept
        {
            return unit_t<unit_type>((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den);
        }
 
        // value if PI *is* involved
        static constexpr const unit_t<unit_type> value(std::true_type) noexcept
        {
            return unit_t<unit_type>(((UNIT_LIB_DEFAULT_TYPE)ratio::num / ratio::den) * std::pow(units::constants::detail::PI_VAL, ((UNIT_LIB_DEFAULT_TYPE)pi_exponent::num / pi_exponent::den)));
        } // END DOXYGEN IGNORE
    };
 
    //------------------------------
    //  LITERALS
    //------------------------------

 
    //------------------------------
    //  LENGTH UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_LENGTH_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(length, meter, meters, m, unit<std::ratio<1>, units::category::length_unit>)
    UNIT_ADD(length, foot, feet, ft, unit<std::ratio<381, 1250>, meters>)
    UNIT_ADD(length, inch, inches, in, unit<std::ratio<1, 12>, feet>)
    UNIT_ADD(length, mil, mils, mil, unit<std::ratio<1000>, inches>)
    UNIT_ADD(length, mile,   miles,    mi,    unit<std::ratio<5280>, feet>)
    UNIT_ADD(length, nauticalMile, nauticalMiles, nmi, unit<std::ratio<1852>, meters>)
    UNIT_ADD(length, astronicalUnit, astronicalUnits, au, unit<std::ratio<149597870700>, meters>)
    UNIT_ADD(length, lightyear, lightyears, ly, unit<std::ratio<9460730472580800>, meters>)
    UNIT_ADD(length, parsec, parsecs, pc, unit<std::ratio<648000>, astronicalUnits, std::ratio<-1>>)
    UNIT_ADD(length, angstrom, angstroms, angstrom, unit<std::ratio<1, 10>, nanometers>)
    UNIT_ADD(length, cubit, cubits, cbt, unit<std::ratio<18>, inches>)
    UNIT_ADD(length, fathom, fathoms, ftm, unit<std::ratio<6>, feet>)
    UNIT_ADD(length, chain, chains, ch, unit<std::ratio<66>, feet>)
    UNIT_ADD(length, furlong, furlongs, fur, unit<std::ratio<10>, chains>)
    UNIT_ADD(length, hand, hands, hand, unit<std::ratio<4>, inches>)
    UNIT_ADD(length, league, leagues, lea, unit<std::ratio<3>, miles>)
    UNIT_ADD(length, nauticalLeague, nauticalLeagues, nl, unit<std::ratio<3>, nauticalMiles>)
    UNIT_ADD(length, yard, yards, yd, unit<std::ratio<3>, feet>)
 
    UNIT_ADD_CATEGORY_TRAIT(length)
#endif
 
    //------------------------------
    //  MASS UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_MASS_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(mass, gram, grams, g, unit<std::ratio<1, 1000>, units::category::mass_unit>)
    UNIT_ADD(mass, metric_ton, metric_tons, t, unit<std::ratio<1000>, kilograms>)
    UNIT_ADD(mass, pound, pounds, lb, unit<std::ratio<45359237, 100000000>, kilograms>)
    UNIT_ADD(mass, long_ton, long_tons, ln_t, unit<std::ratio<2240>, pounds>)
    UNIT_ADD(mass, short_ton, short_tons, sh_t, unit<std::ratio<2000>, pounds>)
    UNIT_ADD(mass, stone, stone, st, unit<std::ratio<14>, pounds>)
    UNIT_ADD(mass, ounce, ounces, oz, unit<std::ratio<1, 16>, pounds>)
    UNIT_ADD(mass, carat, carats, ct, unit<std::ratio<200>, milligrams>)
    UNIT_ADD(mass, slug, slugs, slug, unit<std::ratio<145939029, 10000000>, kilograms>)
 
    UNIT_ADD_CATEGORY_TRAIT(mass)
#endif
 
    //------------------------------
    //  TIME UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_TIME_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(time, second, seconds, s, unit<std::ratio<1>, units::category::time_unit>)
    UNIT_ADD(time, minute, minutes, min, unit<std::ratio<60>, seconds>)
    UNIT_ADD(time, hour, hours, hr, unit<std::ratio<60>, minutes>)
    UNIT_ADD(time, day, days, d, unit<std::ratio<24>, hours>)
    UNIT_ADD(time, week, weeks, wk, unit<std::ratio<7>, days>)
    UNIT_ADD(time, year, years, yr, unit<std::ratio<365>, days>)
    UNIT_ADD(time, julian_year, julian_years, a_j,  unit<std::ratio<31557600>, seconds>)
    UNIT_ADD(time, gregorian_year, gregorian_years, a_g, unit<std::ratio<31556952>, seconds>)
 
    UNIT_ADD_CATEGORY_TRAIT(time)
#endif
 
    //------------------------------
    //  ANGLE UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(angle, radian, radians, rad, unit<std::ratio<1>, units::category::angle_unit>)
    UNIT_ADD(angle, degree, degrees, deg, unit<std::ratio<1, 180>, radians, std::ratio<1>>)
    UNIT_ADD(angle, arcminute, arcminutes, arcmin, unit<std::ratio<1, 60>, degrees>)
    UNIT_ADD(angle, arcsecond, arcseconds, arcsec, unit<std::ratio<1, 60>, arcminutes>)
    UNIT_ADD(angle, milliarcsecond, milliarcseconds, mas, milli<arcseconds>)
    UNIT_ADD(angle, turn, turns, tr, unit<std::ratio<2>, radians, std::ratio<1>>)
    UNIT_ADD(angle, gradian, gradians, gon, unit<std::ratio<1, 400>, turns>)
 
    UNIT_ADD_CATEGORY_TRAIT(angle)
#endif
 
    //------------------------------
    //  UNITS OF CURRENT
    //------------------------------
#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CURRENT_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(current, ampere, amperes, A, unit<std::ratio<1>, units::category::current_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(current)
#endif
 
    //------------------------------
    //  UNITS OF TEMPERATURE
    //------------------------------
 
    // NOTE: temperature units have special conversion overloads, since they
    // require translations and aren't a reversible transform.

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_TEMPERATURE_UNITS)
    UNIT_ADD(temperature, kelvin, kelvin, K, unit<std::ratio<1>, units::category::temperature_unit>)
    UNIT_ADD(temperature, celsius, celsius, degC, unit<std::ratio<1>, kelvin, std::ratio<0>, std::ratio<27315, 100>>)
    UNIT_ADD(temperature, fahrenheit, fahrenheit, degF, unit<std::ratio<5, 9>, celsius, std::ratio<0>, std::ratio<-160, 9>>)
    UNIT_ADD(temperature, reaumur, reaumur, Re, unit<std::ratio<10, 8>, celsius>)
    UNIT_ADD(temperature, rankine, rankine, Ra, unit<std::ratio<5, 9>, kelvin>)
 
    UNIT_ADD_CATEGORY_TRAIT(temperature)
#endif
 
    //------------------------------
    //  UNITS OF AMOUNT OF SUBSTANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_SUBSTANCE_UNITS)
    UNIT_ADD(substance, mole, moles, mol, unit<std::ratio<1>, units::category::substance_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(substance)
#endif
 
    //------------------------------
    //  UNITS OF LUMINOUS INTENSITY
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_LUMINOUS_INTENSITY_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(luminous_intensity, candela, candelas, cd, unit<std::ratio<1>, units::category::luminous_intensity_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(luminous_intensity)
#endif
 
    //------------------------------
    //  UNITS OF SOLID ANGLE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_SOLID_ANGLE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(solid_angle, steradian, steradians, sr, unit<std::ratio<1>, units::category::solid_angle_unit>)
    UNIT_ADD(solid_angle, degree_squared, degrees_squared, sq_deg, squared<angle::degrees>)
    UNIT_ADD(solid_angle, spat, spats, sp, unit<std::ratio<4>, steradians, std::ratio<1>>)
 
    UNIT_ADD_CATEGORY_TRAIT(solid_angle)
#endif
 
    //------------------------------
    //  FREQUENCY UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_FREQUENCY_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(frequency, hertz, hertz, Hz, unit<std::ratio<1>, units::category::frequency_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(frequency)
#endif
 
    //------------------------------
    //  VELOCITY UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_VELOCITY_UNITS)
    UNIT_ADD(velocity, meters_per_second, meters_per_second, mps, unit<std::ratio<1>, units::category::velocity_unit>)
    UNIT_ADD(velocity, feet_per_second, feet_per_second, fps, compound_unit<length::feet, inverse<time::seconds>>)
    UNIT_ADD(velocity, miles_per_hour, miles_per_hour, mph, compound_unit<length::miles, inverse<time::hour>>)
    UNIT_ADD(velocity, kilometers_per_hour, kilometers_per_hour, kph, compound_unit<length::kilometers, inverse<time::hour>>)
    UNIT_ADD(velocity, knot, knots, kts, compound_unit<length::nauticalMiles, inverse<time::hour>>)
 
    UNIT_ADD_CATEGORY_TRAIT(velocity)
#endif
 
    //------------------------------
    //  ANGULAR VELOCITY UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGULAR_VELOCITY_UNITS)
    UNIT_ADD(angular_velocity, radians_per_second, radians_per_second, rad_per_s, unit<std::ratio<1>, units::category::angular_velocity_unit>)
    UNIT_ADD(angular_velocity, degrees_per_second, degrees_per_second, deg_per_s, compound_unit<angle::degrees, inverse<time::seconds>>)
    UNIT_ADD(angular_velocity, revolutions_per_minute, revolutions_per_minute, rpm, unit<std::ratio<2, 60>, radians_per_second, std::ratio<1>>)
    UNIT_ADD(angular_velocity, revolutions_per_second, revolutions_per_second, rps, unit<std::ratio<2, 1>, radians_per_second, std::ratio<1>>)
    UNIT_ADD(angular_velocity, milliarcseconds_per_year, milliarcseconds_per_year, mas_per_yr, compound_unit<angle::milliarcseconds, inverse<time::year>>)
 
    UNIT_ADD_CATEGORY_TRAIT(angular_velocity)
#endif
 
    //------------------------------
    //  UNITS OF ACCELERATION
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ACCELERATION_UNITS)
    UNIT_ADD(acceleration, meters_per_second_squared, meters_per_second_squared, mps_sq, unit<std::ratio<1>, units::category::acceleration_unit>)
    UNIT_ADD(acceleration, feet_per_second_squared, feet_per_second_squared, fps_sq, compound_unit<length::feet, inverse<squared<time::seconds>>>)
    UNIT_ADD(acceleration, standard_gravity, standard_gravity, SG, unit<std::ratio<980665, 100000>, meters_per_second_squared>)
 
    UNIT_ADD_CATEGORY_TRAIT(acceleration)
#endif
 
    //------------------------------
    //  UNITS OF JERK
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_JERK_UNITS)
    UNIT_ADD(jerk, meters_per_second_cubed, meters_per_second_cubed, mps_cb, unit<std::ratio<1>, units::category::jerk_unit>)
    UNIT_ADD(jerk, feet_per_second_cubed, feet_per_second_cubed, fps_cb, compound_unit<length::feet, inverse<cubed<time::seconds>>>)
 
    UNIT_ADD_CATEGORY_TRAIT(jerk)
#endif
 
    //------------------------------
    //  UNITS OF FORCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_FORCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(force, newton, newtons, N, unit<std::ratio<1>, units::category::force_unit>)
    UNIT_ADD(force, pound, pounds, lbf, compound_unit<mass::slug, length::foot, inverse<squared<time::seconds>>>)
    UNIT_ADD(force, dyne, dynes, dyn, unit<std::ratio<1, 100000>, newtons>)
    UNIT_ADD(force, kilopond, kiloponds, kp, compound_unit<acceleration::standard_gravity, mass::kilograms>)
    UNIT_ADD(force, poundal, poundals, pdl, compound_unit<mass::pound, length::foot, inverse<squared<time::seconds>>>)
 
    UNIT_ADD_CATEGORY_TRAIT(force)
#endif
 
    //------------------------------
    //  UNITS OF PRESSURE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_PRESSURE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(pressure, pascal, pascals, Pa, unit<std::ratio<1>, units::category::pressure_unit>)
    UNIT_ADD(pressure, bar, bars, bar, unit<std::ratio<100>, kilo<pascals>>)
    UNIT_ADD(pressure, mbar, mbars, mbar, unit<std::ratio<1>, milli<bar>>)
    UNIT_ADD(pressure, atmosphere, atmospheres, atm, unit<std::ratio<101325>, pascals>)
    UNIT_ADD(pressure, pounds_per_square_inch, pounds_per_square_inch, psi, compound_unit<force::pounds, inverse<squared<length::inch>>>)
    UNIT_ADD(pressure, torr, torrs, torr, unit<std::ratio<1, 760>, atmospheres>)
    UNIT_ADD(pressure, millimeter_of_mercury, millimeters_of_mercury, mmHg, unit<std::ratio<26664477483LL, 200000000LL>, pascals>)
    UNIT_ADD(pressure, inch_of_mercury, inches_of_mercury, inHg, unit<std::ratio<254, 10>, millimeters_of_mercury>)
 
    UNIT_ADD_CATEGORY_TRAIT(pressure)
#endif
 
    //------------------------------
    //  UNITS OF CHARGE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CHARGE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(charge, coulomb, coulombs, C, unit<std::ratio<1>, units::category::charge_unit>)
    UNIT_ADD_WITH_METRIC_PREFIXES(charge, ampere_hour, ampere_hours, Ah, compound_unit<current::ampere, time::hours>)
 
    UNIT_ADD_CATEGORY_TRAIT(charge)
#endif
 
    //------------------------------
    //  UNITS OF ENERGY
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ENERGY_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(energy, joule, joules, J, unit<std::ratio<1>, units::category::energy_unit>)
    UNIT_ADD_WITH_METRIC_PREFIXES(energy, calorie, calories, cal, unit<std::ratio<4184, 1000>, joules>)
    UNIT_ADD(energy, kilowatt_hour, kilowatt_hours, kWh, unit<std::ratio<36, 10>, megajoules>)
    UNIT_ADD(energy, watt_hour, watt_hours, Wh, unit<std::ratio<1, 1000>, kilowatt_hours>)
    UNIT_ADD(energy, british_thermal_unit, british_thermal_units, BTU, unit<std::ratio<105505585262, 100000000>, joules>)
    UNIT_ADD(energy, british_thermal_unit_iso, british_thermal_units_iso, BTU_iso, unit<std::ratio<1055056, 1000>, joules>)
    UNIT_ADD(energy, british_thermal_unit_59, british_thermal_units_59, BTU59, unit<std::ratio<1054804, 1000>, joules>)
    UNIT_ADD(energy, therm, therms, thm, unit<std::ratio<100000>, british_thermal_units_59>)
    UNIT_ADD(energy, foot_pound, foot_pounds, ftlbf, unit<std::ratio<13558179483314004, 10000000000000000>, joules>)
 
    UNIT_ADD_CATEGORY_TRAIT(energy)
#endif
 
    //------------------------------
    //  UNITS OF POWER
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_POWER_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(power, watt, watts, W, unit<std::ratio<1>, units::category::power_unit>)
    UNIT_ADD(power, horsepower, horsepower, hp, unit<std::ratio<7457, 10>, watts>)
    UNIT_ADD_DECIBEL(power, watt, dBW)
    UNIT_ADD_DECIBEL(power, milliwatt, dBm)
 
    UNIT_ADD_CATEGORY_TRAIT(power)
#endif
 
    //------------------------------
    //  UNITS OF VOLTAGE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_VOLTAGE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(voltage, volt, volts, V, unit<std::ratio<1>, units::category::voltage_unit>)
    UNIT_ADD(voltage, statvolt, statvolts, statV, unit<std::ratio<1000000, 299792458>, volts>)
    UNIT_ADD(voltage, abvolt, abvolts, abV, unit<std::ratio<1, 100000000>, volts>)
 
    UNIT_ADD_CATEGORY_TRAIT(voltage)
#endif
 
    //------------------------------
    //  UNITS OF CAPACITANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CAPACITANCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(capacitance, farad, farads, F, unit<std::ratio<1>, units::category::capacitance_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(capacitance)
#endif
 
    //------------------------------
    //  UNITS OF IMPEDANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_IMPEDANCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(impedance, ohm, ohms, Ohm, unit<std::ratio<1>, units::category::impedance_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(impedance)
#endif
 
    //------------------------------
    //  UNITS OF CONDUCTANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CONDUCTANCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(conductance, siemens, siemens, S, unit<std::ratio<1>, units::category::conductance_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(conductance)
#endif
 
    //------------------------------
    //  UNITS OF MAGNETIC FLUX
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_MAGNETIC_FLUX_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(magnetic_flux, weber, webers, Wb, unit<std::ratio<1>, units::category::magnetic_flux_unit>)
    UNIT_ADD(magnetic_flux, maxwell, maxwells, Mx, unit<std::ratio<1, 100000000>, webers>)
 
    UNIT_ADD_CATEGORY_TRAIT(magnetic_flux)
#endif
 
    //----------------------------------------
    //  UNITS OF MAGNETIC FIELD STRENGTH
    //----------------------------------------

    // Unfortunately `_T` is a WINAPI macro, so we have to use `_Te` as the tesla abbreviation.
#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_MAGNETIC_FIELD_STRENGTH_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(magnetic_field_strength, tesla, teslas, Te, unit<std::ratio<1>, units::category::magnetic_field_strength_unit>)
    UNIT_ADD(magnetic_field_strength, gauss, gauss, G, compound_unit<magnetic_flux::maxwell, inverse<squared<length::centimeter>>>)
 
    UNIT_ADD_CATEGORY_TRAIT(magnetic_field_strength)
#endif
 
    //------------------------------
    //  UNITS OF INDUCTANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_INDUCTANCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(inductance, henry, henries, H, unit<std::ratio<1>, units::category::inductance_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(inductance)
#endif
 
    //------------------------------
    //  UNITS OF LUMINOUS FLUX
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_LUMINOUS_FLUX_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(luminous_flux, lumen, lumens, lm, unit<std::ratio<1>, units::category::luminous_flux_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(luminous_flux)
#endif
 
    //------------------------------
    //  UNITS OF ILLUMINANCE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ILLUMINANCE_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(illuminance, lux, luxes, lx, unit<std::ratio<1>, units::category::illuminance_unit>)
    UNIT_ADD(illuminance, footcandle, footcandles, fc, compound_unit<luminous_flux::lumen, inverse<squared<length::foot>>>)
    UNIT_ADD(illuminance, lumens_per_square_inch, lumens_per_square_inch, lm_per_in_sq, compound_unit<luminous_flux::lumen, inverse<squared<length::inch>>>)
    UNIT_ADD(illuminance, phot, phots, ph, compound_unit<luminous_flux::lumens, inverse<squared<length::centimeter>>>)
 
    UNIT_ADD_CATEGORY_TRAIT(illuminance)
#endif
 
    //------------------------------
    //  UNITS OF RADIATION
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_RADIATION_UNITS)
    UNIT_ADD_WITH_METRIC_PREFIXES(radiation, becquerel, becquerels, Bq, unit<std::ratio<1>, units::frequency::hertz>)
    UNIT_ADD_WITH_METRIC_PREFIXES(radiation, gray, grays, Gy, compound_unit<energy::joules, inverse<mass::kilogram>>)
    UNIT_ADD_WITH_METRIC_PREFIXES(radiation, sievert, sieverts, Sv, unit<std::ratio<1>, grays>)
    UNIT_ADD(radiation, curie, curies, Ci, unit<std::ratio<37>, gigabecquerels>)
    UNIT_ADD(radiation, rutherford, rutherfords, rd, unit<std::ratio<1>, megabecquerels>)
    UNIT_ADD(radiation, rad, rads, rads, unit<std::ratio<1>, centigrays>)
 
    UNIT_ADD_CATEGORY_TRAIT(radioactivity)
#endif
 
    //------------------------------
    //  UNITS OF TORQUE
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_TORQUE_UNITS)
    UNIT_ADD(torque, newton_meter, newton_meters, Nm, unit<std::ratio<1>, units::energy::joule>)
    UNIT_ADD(torque, foot_pound, foot_pounds, ftlb, compound_unit<length::foot, force::pounds>)
    UNIT_ADD(torque, foot_poundal, foot_poundals, ftpdl, compound_unit<length::foot, force::poundal>)
    UNIT_ADD(torque, inch_pound, inch_pounds, inlb, compound_unit<length::inch, force::pounds>)
    UNIT_ADD(torque, meter_kilogram, meter_kilograms, mkgf, compound_unit<length::meter, force::kiloponds>)
 
    UNIT_ADD_CATEGORY_TRAIT(torque)
#endif
 
    //------------------------------
    //  AREA UNITS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_AREA_UNITS)
    UNIT_ADD(area, square_meter, square_meters, sq_m, unit<std::ratio<1>, units::category::area_unit>)
    UNIT_ADD(area, square_foot, square_feet, sq_ft, squared<length::feet>)
    UNIT_ADD(area, square_inch, square_inches, sq_in, squared<length::inch>)
    UNIT_ADD(area, square_mile, square_miles, sq_mi, squared<length::miles>)
    UNIT_ADD(area, square_kilometer, square_kilometers, sq_km, squared<length::kilometers>)
    UNIT_ADD(area, hectare, hectares, ha, unit<std::ratio<10000>, square_meters>)
    UNIT_ADD(area, acre, acres, acre, unit<std::ratio<43560>, square_feet>)
 
    UNIT_ADD_CATEGORY_TRAIT(area)
#endif
 
    //------------------------------
    //  UNITS OF VOLUME
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_VOLUME_UNITS)
    UNIT_ADD(volume, cubic_meter, cubic_meters, cu_m, unit<std::ratio<1>, units::category::volume_unit>)
    UNIT_ADD(volume, cubic_millimeter, cubic_millimeters, cu_mm, cubed<length::millimeter>)
    UNIT_ADD(volume, cubic_kilometer, cubic_kilometers, cu_km, cubed<length::kilometer>)
    UNIT_ADD_WITH_METRIC_PREFIXES(volume, liter, liters, L, cubed<deci<length::meter>>)
    UNIT_ADD(volume, cubic_inch, cubic_inches, cu_in, cubed<length::inches>)
    UNIT_ADD(volume, cubic_foot, cubic_feet, cu_ft, cubed<length::feet>)
    UNIT_ADD(volume, cubic_yard, cubic_yards, cu_yd, cubed<length::yards>)
    UNIT_ADD(volume, cubic_mile, cubic_miles, cu_mi, cubed<length::miles>)
    UNIT_ADD(volume, gallon, gallons, gal, unit<std::ratio<231>, cubic_inches>)
    UNIT_ADD(volume, quart, quarts, qt, unit<std::ratio<1, 4>, gallons>)
    UNIT_ADD(volume, pint, pints, pt, unit<std::ratio<1, 2>, quarts>)
    UNIT_ADD(volume, cup, cups, c, unit<std::ratio<1, 2>, pints>)
    UNIT_ADD(volume, fluid_ounce, fluid_ounces, fl_oz, unit<std::ratio<1, 8>, cups>)
    UNIT_ADD(volume, barrel, barrels, bl, unit<std::ratio<42>, gallons>)
    UNIT_ADD(volume, bushel, bushels, bu, unit<std::ratio<215042, 100>, cubic_inches>)
    UNIT_ADD(volume, cord, cords, cord, unit<std::ratio<128>, cubic_feet>)
    UNIT_ADD(volume, cubic_fathom, cubic_fathoms, cu_fm, cubed<length::fathom>)
    UNIT_ADD(volume, tablespoon, tablespoons, tbsp, unit<std::ratio<1, 2>, fluid_ounces>)
    UNIT_ADD(volume, teaspoon, teaspoons, tsp, unit<std::ratio<1, 6>, fluid_ounces>)
    UNIT_ADD(volume, pinch, pinches, pinch, unit<std::ratio<1, 8>, teaspoons>)
    UNIT_ADD(volume, dash, dashes, dash, unit<std::ratio<1, 2>, pinches>)
    UNIT_ADD(volume, drop, drops, drop, unit<std::ratio<1, 360>, fluid_ounces>)
    UNIT_ADD(volume, fifth, fifths, fifth, unit<std::ratio<1, 5>, gallons>)
    UNIT_ADD(volume, dram, drams, dr, unit<std::ratio<1, 8>, fluid_ounces>)
    UNIT_ADD(volume, gill, gills, gi, unit<std::ratio<4>, fluid_ounces>)
    UNIT_ADD(volume, peck, pecks, pk, unit<std::ratio<1, 4>, bushels>)
    UNIT_ADD(volume, sack, sacks, sacks, unit<std::ratio<3>, bushels>)
    UNIT_ADD(volume, shot, shots, shots, unit<std::ratio<3, 2>, fluid_ounces>)
    UNIT_ADD(volume, strike, strikes, strikes, unit<std::ratio<2>, bushels>)
 
    UNIT_ADD_CATEGORY_TRAIT(volume)
#endif
 
    //------------------------------
    //  UNITS OF DENSITY
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_DENSITY_UNITS)
    UNIT_ADD(density, kilograms_per_cubic_meter, kilograms_per_cubic_meter, kg_per_cu_m, unit<std::ratio<1>, units::category::density_unit>)
    UNIT_ADD(density, grams_per_milliliter, grams_per_milliliter, g_per_mL, compound_unit<mass::grams, inverse<volume::milliliter>>)
    UNIT_ADD(density, kilograms_per_liter, kilograms_per_liter, kg_per_L, unit<std::ratio<1>, compound_unit<mass::grams, inverse<volume::milliliter>>>)
    UNIT_ADD(density, ounces_per_cubic_foot, ounces_per_cubic_foot, oz_per_cu_ft, compound_unit<mass::ounces, inverse<volume::cubic_foot>>)
    UNIT_ADD(density, ounces_per_cubic_inch, ounces_per_cubic_inch, oz_per_cu_in, compound_unit<mass::ounces, inverse<volume::cubic_inch>>)
    UNIT_ADD(density, ounces_per_gallon, ounces_per_gallon, oz_per_gal, compound_unit<mass::ounces, inverse<volume::gallon>>)
    UNIT_ADD(density, pounds_per_cubic_foot, pounds_per_cubic_foot, lb_per_cu_ft, compound_unit<mass::pounds, inverse<volume::cubic_foot>>)
    UNIT_ADD(density, pounds_per_cubic_inch, pounds_per_cubic_inch, lb_per_cu_in, compound_unit<mass::pounds, inverse<volume::cubic_inch>>)
    UNIT_ADD(density, pounds_per_gallon, pounds_per_gallon, lb_per_gal, compound_unit<mass::pounds, inverse<volume::gallon>>)
    UNIT_ADD(density, slugs_per_cubic_foot, slugs_per_cubic_foot, slug_per_cu_ft, compound_unit<mass::slugs, inverse<volume::cubic_foot>>)
 
    UNIT_ADD_CATEGORY_TRAIT(density)
#endif
 
    //------------------------------
    //  UNITS OF CONCENTRATION
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CONCENTRATION_UNITS)
    UNIT_ADD(concentration, ppm, parts_per_million, ppm, unit<std::ratio<1, 1000000>, units::category::scalar_unit>)
    UNIT_ADD(concentration, ppb, parts_per_billion, ppb, unit<std::ratio<1, 1000>, parts_per_million>)
    UNIT_ADD(concentration, ppt, parts_per_trillion, ppt, unit<std::ratio<1, 1000>, parts_per_billion>)
    UNIT_ADD(concentration, percent, percent, pct, unit<std::ratio<1, 100>, units::category::scalar_unit>)
 
    UNIT_ADD_CATEGORY_TRAIT(concentration)
#endif
 
    //------------------------------
    //  UNITS OF DATA
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_DATA_UNITS)
    UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(data, byte, bytes, B, unit<std::ratio<1>, units::category::data_unit>)
    UNIT_ADD(data, exabyte, exabytes, EB, unit<std::ratio<1000>, petabytes>)
    UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(data, bit, bits, b, unit<std::ratio<1, 8>, byte>)
    UNIT_ADD(data, exabit, exabits, Eb, unit<std::ratio<1000>, petabits>)
 
    UNIT_ADD_CATEGORY_TRAIT(data)
#endif
 
    //------------------------------
    //  UNITS OF DATA TRANSFER
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_DATA_TRANSFER_RATE_UNITS)
    UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(data_transfer_rate, bytes_per_second, bytes_per_second, Bps, unit<std::ratio<1>, units::category::data_transfer_rate_unit>)
    UNIT_ADD(data_transfer_rate, exabytes_per_second, exabytes_per_second, EBps, unit<std::ratio<1000>, petabytes_per_second>)
    UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(data_transfer_rate, bits_per_second, bits_per_second, bps, unit<std::ratio<1, 8>, bytes_per_second>)
    UNIT_ADD(data_transfer_rate, exabits_per_second, exabits_per_second, Ebps, unit<std::ratio<1000>, petabits_per_second>)
 
    UNIT_ADD_CATEGORY_TRAIT(data_transfer_rate)
#endif
 
    //------------------------------
    //  CONSTANTS
    //------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_CONSTANTS_UNITS)
    namespace constants
    {
        #undef PI
        using PI = unit<std::ratio<1>, dimensionless::scalar, std::ratio<1>>;
 
        static constexpr const unit_t<PI>                                                                                                         pi(1);                                            
        static constexpr const velocity::meters_per_second_t                                                                                        c(299792458.0);                                    
        static constexpr const unit_t<compound_unit<cubed<length::meters>, inverse<mass::kilogram>, inverse<squared<time::seconds>>>>                G(6.67408e-11);                                    
        static constexpr const unit_t<compound_unit<energy::joule, time::seconds>>                                                                    h(6.626070040e-34);                                
        static constexpr const unit_t<compound_unit<force::newtons, inverse<squared<current::ampere>>>>                                                mu0(pi * 4.0e-7 * force::newton_t(1) / units::math::cpow<2>(current::ampere_t(1)));                                        
        static constexpr const unit_t<compound_unit<capacitance::farad, inverse<length::meter>>>                                                 epsilon0(1.0 / (mu0 * math::cpow<2>(c)));      
        static constexpr const impedance::ohm_t                                                                                                     Z0(mu0 * c);                                  
        static constexpr const unit_t<compound_unit<force::newtons, area::square_meter, inverse<squared<charge::coulomb>>>>                            k_e(1.0 / (4 * pi * epsilon0));                    
        static constexpr const charge::coulomb_t                                                                                                    e(1.6021766208e-19);                           
        static constexpr const mass::kilogram_t                                                                                                     m_e(9.10938356e-31);                         
        static constexpr const mass::kilogram_t                                                                                                     m_p(1.672621898e-27);                            
        static constexpr const unit_t<compound_unit<energy::joules, inverse<magnetic_field_strength::tesla>>>                                       mu_B(e * h / (4 * pi *m_e));                 
        static constexpr const unit_t<inverse<substance::mol>>                                                                                        N_A(6.022140857e23);                         
        static constexpr const unit_t<compound_unit<energy::joules, inverse<temperature::kelvin>, inverse<substance::moles>>>                     R(8.3144598);                                  
        static constexpr const unit_t<compound_unit<energy::joules, inverse<temperature::kelvin>>>                                                 k_B(R / N_A);                                    
        static constexpr const unit_t<compound_unit<charge::coulomb, inverse<substance::mol>>>                                                     F(N_A * e);                                        
        static constexpr const unit_t<compound_unit<power::watts, inverse<area::square_meters>, inverse<squared<squared<temperature::kelvin>>>>> sigma((2 * math::cpow<5>(pi) * math::cpow<4>(R)) / (15 * math::cpow<3>(h) * math::cpow<2>(c) * math::cpow<4>(N_A)));  
    }
#endif
 
    //----------------------------------
    //  UNIT-ENABLED CMATH FUNCTIONS
    //----------------------------------

    namespace math
    {
 
        //----------------------------------
        //  MIN/MAX FUNCTIONS
        //----------------------------------
 
        template<class UnitTypeLhs, class UnitTypeRhs>
        UnitTypeLhs min(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs)
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Unit types are not compatible.");
            UnitTypeLhs r(rhs);
            return (lhs < r ? lhs : r);
        }
 
        template<class UnitTypeLhs, class UnitTypeRhs>
        UnitTypeLhs max(const UnitTypeLhs& lhs, const UnitTypeRhs& rhs)
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Unit types are not compatible.");
            UnitTypeLhs r(rhs);
            return (lhs > r ? lhs : r);
        }
 
        //----------------------------------
        //  TRIGONOMETRIC FUNCTIONS
        //----------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t cos(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::cos(angle.template convert<angle::radian>()()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t sin(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::sin(angle.template convert<angle::radian>()()));
        }
#endif
#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t tan(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::tan(angle.template convert<angle::radian>()()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t acos(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::acos(x.value()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t asin(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::asin(x.value()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t atan(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::atan(x.value()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class Y, class X>
        angle::radian_t atan2(const Y y, const X x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<decltype(y/x)>::value, "The quantity y/x must yield a dimensionless ratio.");
 
            // X and Y could be different length units, so normalize them
            return angle::radian_t(std::atan2(y.template convert<typename units::traits::unit_t_traits<X>::unit_type>()(), x()));
        }
#endif
 
        //----------------------------------
        //  HYPERBOLIC TRIG FUNCTIONS
        //----------------------------------

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t cosh(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::cosh(angle.template convert<angle::radian>()()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t sinh(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::sinh(angle.template convert<angle::radian>()()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class AngleUnit>
        dimensionless::scalar_t tanh(const AngleUnit angle) noexcept
        {
            static_assert(traits::is_angle_unit<AngleUnit>::value, "Type `AngleUnit` must be a unit of angle derived from `unit_t`.");
            return dimensionless::scalar_t(std::tanh(angle.template convert<angle::radian>()()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t acosh(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::acosh(x.value()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t asinh(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::asinh(x.value()));
        }
#endif

#if !defined(DISABLE_PREDEFINED_UNITS) || defined(ENABLE_PREDEFINED_ANGLE_UNITS)
        template<class ScalarUnit>
        angle::radian_t atanh(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return angle::radian_t(std::atanh(x.value()));
        }
#endif
 
        //----------------------------------
        //  TRANSCENDENTAL FUNCTIONS
        //----------------------------------
 
        // it makes NO SENSE to put dimensioned units into a transcendental function, and if you think it does you are
        // demonstrably wrong. https://en.wikipedia.org/wiki/Transcendental_function#Dimensional_analysis

        template<class ScalarUnit>
        dimensionless::scalar_t exp(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::exp(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t log(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::log(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t log10(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::log10(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t modf(const ScalarUnit x, ScalarUnit* intpart) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
 
            UNIT_LIB_DEFAULT_TYPE intp;
            dimensionless::scalar_t fracpart = dimensionless::scalar_t(std::modf(x.value(), &intp));
            *intpart = intp;
            return fracpart;
        }

        template<class ScalarUnit>
        dimensionless::scalar_t exp2(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::exp2(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t expm1(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::expm1(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t log1p(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::log1p(x.value()));
        }

        template<class ScalarUnit>
        dimensionless::scalar_t log2(const ScalarUnit x) noexcept
        {
            static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
            return dimensionless::scalar_t(std::log2(x.value()));
        }
 
        //----------------------------------
        //  POWER FUNCTIONS
        //----------------------------------
 
        /* pow is implemented earlier in the library since a lot of the unit definitions depend on it */

        template<class UnitType, std::enable_if_t<units::traits::has_linear_scale<UnitType>::value, int> = 0>
        inline auto sqrt(const UnitType& value) noexcept -> unit_t<square_root<typename units::traits::unit_t_traits<UnitType>::unit_type>, typename units::traits::unit_t_traits<UnitType>::underlying_type, linear_scale>
        {
            return unit_t<square_root<typename units::traits::unit_t_traits<UnitType>::unit_type>, typename units::traits::unit_t_traits<UnitType>::underlying_type, linear_scale>
                (std::sqrt(value()));
        }

        template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<units::traits::has_linear_scale<UnitTypeLhs, UnitTypeRhs>::value, int> = 0>
        inline UnitTypeLhs hypot(const UnitTypeLhs& x, const UnitTypeRhs& y)
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Parameters of hypot() function are not compatible units.");
            return UnitTypeLhs(std::hypot(x(), y.template convert<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>()()));
        }
 
        //----------------------------------
        //  ROUNDING FUNCTIONS
        //----------------------------------

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType ceil(const UnitType x) noexcept
        {
            return UnitType(std::ceil(x()));
        }

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType floor(const UnitType x) noexcept
        {
            return UnitType(std::floor(x()));
        }

        template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
        UnitTypeLhs fmod(const UnitTypeLhs numer, const UnitTypeRhs denom) noexcept
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Parameters of fmod() function are not compatible units.");
            return UnitTypeLhs(std::fmod(numer(), denom.template convert<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>()()));
        }

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType trunc(const UnitType x) noexcept
        {
            return UnitType(std::trunc(x()));
        }
 

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType round(const UnitType x) noexcept
        {
            return UnitType(std::round(x()));
        }
 
        //----------------------------------
        //  FLOATING POINT MANIPULATION
        //----------------------------------

        template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
        UnitTypeLhs copysign(const UnitTypeLhs x, const UnitTypeRhs y) noexcept
        {
            return UnitTypeLhs(std::copysign(x(), y()));    // no need for conversion to get the correct sign.
        }

        template<class UnitTypeLhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value>>
        UnitTypeLhs copysign(const UnitTypeLhs x, const UNIT_LIB_DEFAULT_TYPE y) noexcept
        {
            return UnitTypeLhs(std::copysign(x(), y));
        }
 
        //----------------------------------
        //  MIN / MAX / DIFFERENCE
        //----------------------------------

        template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
        UnitTypeLhs fdim(const UnitTypeLhs x, const UnitTypeRhs y) noexcept
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Parameters of fdim() function are not compatible units.");
            return UnitTypeLhs(std::fdim(x(), y.template convert<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>()()));
        }

        template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
        UnitTypeLhs fmax(const UnitTypeLhs x, const UnitTypeRhs y) noexcept
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Parameters of fmax() function are not compatible units.");
            return UnitTypeLhs(std::fmax(x(), y.template convert<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>()()));
        }

        template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
        UnitTypeLhs fmin(const UnitTypeLhs x, const UnitTypeRhs y) noexcept
        {
            static_assert(traits::is_convertible_unit_t<UnitTypeLhs, UnitTypeRhs>::value, "Parameters of fmin() function are not compatible units.");
            return UnitTypeLhs(std::fmin(x(), y.template convert<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>()()));
        }
 
        //----------------------------------
        //  OTHER FUNCTIONS
        //----------------------------------

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType fabs(const UnitType x) noexcept
        {
            return UnitType(std::fabs(x()));
        }

        template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
        UnitType abs(const UnitType x) noexcept
        {
            return UnitType(std::fabs(x()));
        }

        template<class UnitTypeLhs, class UnitMultiply, class UnitAdd, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitMultiply>::value && traits::is_unit_t<UnitAdd>::value>>
        auto fma(const UnitTypeLhs x, const UnitMultiply y, const UnitAdd z) noexcept -> decltype(x * y)
        {
            using resultType = decltype(x * y);
            static_assert(traits::is_convertible_unit_t<compound_unit<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type, typename units::traits::unit_t_traits<UnitMultiply>::unit_type>, typename units::traits::unit_t_traits<UnitAdd>::unit_type>::value, "Unit types are not compatible.");
            return resultType(std::fma(x(), y(), resultType(z)()));
        }
 
    }   // end namespace math
}   // end namespace units
 
//------------------------------
//  std::numeric_limits
//------------------------------
 
namespace std
{
    template<class Units, typename T, template<typename> class NonLinearScale>
    class numeric_limits<units::unit_t<Units, T, NonLinearScale>>
    {
    public:
        static constexpr units::unit_t<Units, T, NonLinearScale> min()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::min());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> denorm_min() noexcept
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::denorm_min());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> max()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::max());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> lowest()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::lowest());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> epsilon()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::epsilon());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> round_error()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::round_error());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> infinity()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::infinity());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> quiet_NaN()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::quiet_NaN());
        }
        static constexpr units::unit_t<Units, T, NonLinearScale> signaling_NaN()
        {
            return units::unit_t<Units, T, NonLinearScale>(std::numeric_limits<T>::signaling_NaN());
        }
        static constexpr bool is_specialized = std::numeric_limits<T>::is_specialized;
        static constexpr bool is_signed = std::numeric_limits<T>::is_signed;
        static constexpr bool is_integer = std::numeric_limits<T>::is_integer;
        static constexpr bool is_exact = std::numeric_limits<T>::is_exact;
        static constexpr bool has_infinity = std::numeric_limits<T>::has_infinity;
        static constexpr bool has_quiet_NaN = std::numeric_limits<T>::has_quiet_NaN;
        static constexpr bool has_signaling_NaN = std::numeric_limits<T>::has_signaling_NaN;
    };
 
    template<class Units, typename T, template<typename> class NonLinearScale>
    bool isnan(const units::unit_t<Units, T, NonLinearScale>& x)
    {
        return std::isnan(x());
    }
 
    template<class Units, typename T, template<typename> class NonLinearScale>
    bool isinf(const units::unit_t<Units, T, NonLinearScale>& x)
    {
        return std::isinf(x());
    }
 
    template<class Units, typename T, template<typename> class NonLinearScale>
    bool signbit(const units::unit_t<Units, T, NonLinearScale>& x)
    {
        return std::signbit(x());
    }
}
 
#ifdef _MSC_VER
#   if _MSC_VER <= 1800
#       pragma warning(pop)
#       undef constexpr
#       pragma pop_macro("constexpr")
#       undef noexcept
#       pragma pop_macro("noexcept")
#       undef _ALLOW_KEYWORD_MACROS
#   endif // _MSC_VER < 1800
#   pragma pop_macro("pascal")
#endif // _MSC_VER
 
#if defined(__MINGW64__) || defined(__MINGW32__)
#   pragma pop_macro("pascal")
#endif // __MINGW64__ or __MINGW32__
 
#endif // units_h__
 
// For Emacs
// Local Variables:
// Mode: C++
// c-basic-offset: 2
// fill-column: 116
// tab-width: 4
// End: