units.h File Reference

Complete implementation of units - a compile-time, header-only, unit conversion library built on c++14 with no dependencies. More...

#include <chrono>
#include <cstddef>
#include <ratio>
#include <type_traits>
#include <cstdint>
#include <cmath>
#include <limits>
#include <iostream>
#include <string>
#include <locale>

Go to the source code of this file.

Classes
struct	units::traits::is_ratio< T >
	Trait that tests whether a type represents a std::ratio. More...
struct	units::traits::is_base_unit< T >
	Trait which tests if a class is a base_unit type. More...
struct	units::traits::is_unit< T >
	Traits which tests if a class is a unit. More...
struct	units::base_unit< Meter, Kilogram, Second, Radian, Ampere, Kelvin, Mole, Candela, Byte >
	Class representing SI base unit types. More...
struct	units::unit< Conversion, BaseUnit, PiExponent, Translation >
	Type representing an arbitrary unit. More...
struct	units::traits::is_convertible_unit< U1, U2 >
	Trait which checks whether two units can be converted to each other. More...
struct	units::traits::is_nonlinear_scale< T, Ret >
	Trait which tests that class T meets the requirements for a non-linear scale. More...
struct	units::traits::is_convertible_unit_t< U1, U2 >
	Trait which tests whether two container types derived from unit_t are convertible to each other. More...
struct	units::traits::is_unit_t< T >
	Traits which tests if a class is a unit. More...
class	units::unit_t< Units, T, NonLinearScale >
	Container for values which represent quantities of a given unit. More...
struct	units::traits::has_linear_scale< T >
	Trait which tests whether a type is inherited from a linear scale. More...
struct	units::traits::has_decibel_scale< T >
	Trait which tests whether a type is inherited from a decibel scale. More...
struct	units::traits::is_same_scale< T1, T2 >
	Trait which tests whether two types has the same non-linear scale. More...
struct	units::linear_scale< T >
	unit_t scale which is linear More...
struct	units::traits::detail::is_scalar_unit_impl< T >
struct	units::traits::detail::is_scalar_unit_impl< units::unit< C, U, P, T > >
struct	units::traits::detail::is_scalar_unit_impl< units::unit_t< U, S, N > >
struct	units::traits::is_scalar_unit< T >
struct	units::traits::detail::is_dimensionless_unit_impl< T >
struct	units::traits::detail::is_dimensionless_unit_impl< units::unit< C, U, P, T > >
struct	units::traits::detail::is_dimensionless_unit_impl< units::unit_t< U, S, N > >
struct	units::traits::is_dimensionless_unit< T >
struct	units::decibel_scale< T >
	unit_t scale for representing decibel values. More...
struct	units::unit_value_t< Units, Num, Denom >
	Stores a rational unit value as a compile-time constant. More...
struct	units::traits::is_unit_value_t< T, Units >
	Trait which tests whether a type is a unit_value_t representing the given unit type. More...
struct	units::traits::is_unit_value_t_category< Category, T >
	Trait which tests whether type T is a unit_value_t with a unit type in the given category. More...
struct	units::unit_value_add< U1, U2 >
	adds two unit_value_t types at compile-time More...
struct	units::unit_value_subtract< U1, U2 >
	subtracts two unit_value_t types at compile-time More...
struct	units::unit_value_multiply< U1, U2 >
	multiplies two unit_value_t types at compile-time More...
struct	units::unit_value_divide< U1, U2 >
	divides two unit_value_t types at compile-time More...
struct	units::unit_value_power< U1, power >
	raises unit_value_to a power at compile-time More...
struct	units::unit_value_sqrt< U1, Eps >
	calculates square root of unit_value_t at compile-time More...
struct	units::traits::is_length_unit< T >
struct	units::traits::is_mass_unit< T >
struct	units::traits::is_time_unit< T >
struct	units::traits::is_angle_unit< T >
struct	units::traits::is_current_unit< T >
struct	units::traits::is_temperature_unit< T >
struct	units::traits::is_substance_unit< T >
struct	units::traits::is_luminous_intensity_unit< T >
struct	units::traits::is_solid_angle_unit< T >
struct	units::traits::is_frequency_unit< T >
struct	units::traits::is_velocity_unit< T >
struct	units::traits::is_angular_velocity_unit< T >
struct	units::traits::is_acceleration_unit< T >
struct	units::traits::is_jerk_unit< T >
struct	units::traits::is_force_unit< T >
struct	units::traits::is_pressure_unit< T >
struct	units::traits::is_charge_unit< T >
struct	units::traits::is_energy_unit< T >
struct	units::traits::is_power_unit< T >
struct	units::traits::is_voltage_unit< T >
struct	units::traits::is_capacitance_unit< T >
struct	units::traits::is_impedance_unit< T >
struct	units::traits::is_conductance_unit< T >
struct	units::traits::is_magnetic_flux_unit< T >
struct	units::traits::is_magnetic_field_strength_unit< T >
struct	units::traits::is_inductance_unit< T >
struct	units::traits::is_luminous_flux_unit< T >
struct	units::traits::is_illuminance_unit< T >
struct	units::traits::is_radioactivity_unit< T >
struct	units::traits::is_torque_unit< T >
struct	units::traits::is_area_unit< T >
struct	units::traits::is_volume_unit< T >
struct	units::traits::is_density_unit< T >
struct	units::traits::is_concentration_unit< T >
struct	units::traits::is_data_unit< T >
struct	units::traits::is_data_transfer_rate_unit< T >
class	std::numeric_limits< units::unit_t< Units, T, NonLinearScale > >

Namespaces
namespace	units
	Unit Conversion Library namespace.
namespace	units::traits
	namespace representing type traits which can access the properties of types provided by the units library.
namespace	units::category
	namespace representing the implemented base and derived unit types.
namespace	units::dimensionless
	namespace for unit types and containers for units that have no dimension (scalar units)
namespace	units::traits::detail
	@cond
namespace	units::math
	namespace for unit-enabled versions of the <cmath> library
namespace	units::literals
	namespace for unit literal definitions of all categories.
namespace	units::length
	namespace for unit types and containers representing length values
namespace	units::mass
	namespace for unit types and containers representing mass values
namespace	units::time
	namespace for unit types and containers representing time values
namespace	units::angle
	namespace for unit types and containers representing angle values
namespace	units::current
	namespace for unit types and containers representing current values
namespace	units::temperature
	namespace for unit types and containers representing temperature values
namespace	units::substance
	namespace for unit types and containers representing substance values
namespace	units::luminous_intensity
	namespace for unit types and containers representing luminous_intensity values
namespace	units::solid_angle
	namespace for unit types and containers representing solid_angle values
namespace	units::frequency
	namespace for unit types and containers representing frequency values
namespace	units::velocity
	namespace for unit types and containers representing velocity values
namespace	units::angular_velocity
	namespace for unit types and containers representing angular velocity values
namespace	units::acceleration
	namespace for unit types and containers representing acceleration values
namespace	units::jerk
	namespace for unit types and containers representing jerk values
namespace	units::force
	namespace for unit types and containers representing force values
namespace	units::pressure
	namespace for unit types and containers representing pressure values
namespace	units::charge
	namespace for unit types and containers representing charge values
namespace	units::energy
	namespace for unit types and containers representing energy values
namespace	units::power
	namespace for unit types and containers representing power values
namespace	units::voltage
	namespace for unit types and containers representing voltage values
namespace	units::capacitance
	namespace for unit types and containers representing capacitance values
namespace	units::impedance
	namespace for unit types and containers representing impedance values
namespace	units::conductance
	namespace for unit types and containers representing conductance values
namespace	units::magnetic_flux
	namespace for unit types and containers representing magnetic_flux values
namespace	units::magnetic_field_strength
	namespace for unit types and containers representing magnetic_field_strength values
namespace	units::inductance
	namespace for unit types and containers representing inductance values
namespace	units::luminous_flux
	namespace for unit types and containers representing luminous_flux values
namespace	units::illuminance
	namespace for unit types and containers representing illuminance values
namespace	units::radiation
	namespace for unit types and containers representing radiation values
namespace	units::torque
	namespace for unit types and containers representing torque values
namespace	units::area
	namespace for unit types and containers representing area values
namespace	units::volume
	namespace for unit types and containers representing volume values
namespace	units::density
	namespace for unit types and containers representing density values
namespace	units::concentration
	namespace for unit types and containers representing concentration values
namespace	units::data
	namespace for unit types and containers representing data values
namespace	units::data_transfer_rate
	namespace for unit types and containers representing data values
namespace	units::constants
	namespace for physical constants like PI and Avogadro's Number.
namespace	std
	STL namespace.

Macros
#define	units_h__
#define	UNIT_HAS_LITERAL_SUPPORT
#define	UNIT_HAS_VARIADIC_TEMPLATE_SUPPORT
#define	UNIT_LIB_DEFAULT_TYPE   double
#define	UNIT_ADD_UNIT_TAGS(namespaceName, nameSingular, namePlural, abbreviation, ...)
	Helper macro for generating the boiler-plate code generating the tags of a new unit.
#define	UNIT_ADD_UNIT_DEFINITION(namespaceName, nameSingular)
	Macro for generating the boiler-plate code for the unit_t type definition.
#define	UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION(namespaceName, nameSingular, underlyingType)
	Macro for generating the boiler-plate code for a unit_t type definition with a non-default underlying type.
#define	UNIT_ADD_IO(namespaceName, nameSingular, abbrev)
	Macro for generating the boiler-plate code needed for I/O for a new unit.
#define	UNIT_ADD_NAME(namespaceName, nameSingular, namePlural, abbrev)
	Macro for generating constexpr names/abbreviations for units.
#define	UNIT_ADD_LITERALS(namespaceName, nameSingular, abbreviation)
	Macro for generating user-defined literals for units.
#define	UNIT_ADD(namespaceName, nameSingular, namePlural, abbreviation, ...)
	Macro for generating the boiler-plate code needed for a new unit.
#define	UNIT_ADD_WITH_CUSTOM_TYPE(namespaceName, nameSingular, namePlural, abbreviation, underlyingType, ...)
	Macro for generating the boiler-plate code needed for a new unit with a non-default underlying type.
#define	UNIT_ADD_DECIBEL(namespaceName, nameSingular, abbreviation)
	Macro to create decibel container and literals for an existing unit type.
#define	UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)
#define	UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)
#define	UNIT_ADD_CATEGORY_TRAIT(unitCategory)
	Macro to create the is_category_unit type trait.
#define	UNIT_ADD_WITH_METRIC_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)
	Macro for generating the boiler-plate code needed for a new unit, including its metric prefixes from femto to peta.
#define	UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(namespaceName, nameSingular, namePlural, abbreviation, ...)
	Macro for generating the boiler-plate code needed for a new unit, including its metric prefixes from femto to peta, and binary prefixes from kibi to exbi.

Typedefs
typedef base_unit	units::category::scalar_unit
	Represents a quantity with no dimension.
typedef base_unit	units::category::dimensionless_unit
	Represents a quantity with no dimension.
typedef base_unit< detail::meter_ratio< 1 > >	units::category::length_unit
	Represents an SI base unit of length.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 1 > >	units::category::mass_unit
	Represents an SI base unit of mass.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > >	units::category::time_unit
	Represents an SI base unit of time.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > >	units::category::angle_unit
	Represents an SI base unit of angle.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > >	units::category::current_unit
	Represents an SI base unit of current.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 0 >, std::ratio< 1 > >	units::category::temperature_unit
	Represents an SI base unit of temperature.
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 > >	units::category::substance_unit
	Represents an SI base unit of amount of substance.
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 > >	units::category::luminous_intensity_unit
	Represents an SI base unit of luminous intensity.
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 > >	units::category::solid_angle_unit
	Represents an SI derived unit of solid angle.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::frequency_unit
	Represents an SI derived unit of frequency.
typedef base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::velocity_unit
	Represents an SI derived unit of velocity.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 >, std::ratio< 1 > >	units::category::angular_velocity_unit
	Represents an SI derived unit of angular velocity.
typedef base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-2 > >	units::category::acceleration_unit
	Represents an SI derived unit of acceleration.
typedef base_unit< detail::meter_ratio< 1 >, std::ratio< 0 >, std::ratio<-3 > >	units::category::jerk_unit
	Represents an SI derived unit of jerk.
typedef base_unit< detail::meter_ratio< 1 >, std::ratio< 1 >, std::ratio<-2 > >	units::category::force_unit
	Represents an SI derived unit of force.
typedef base_unit< detail::meter_ratio<-1 >, std::ratio< 1 >, std::ratio<-2 > >	units::category::pressure_unit
	Represents an SI derived unit of pressure.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio< 1 >, std::ratio< 0 >, std::ratio< 1 > >	units::category::charge_unit
	Represents an SI derived unit of charge.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > >	units::category::energy_unit
	Represents an SI derived unit of energy.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 > >	units::category::power_unit
	Represents an SI derived unit of power.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::voltage_unit
	Represents an SI derived unit of voltage.
typedef base_unit< detail::meter_ratio<-2 >, std::ratio<-1 >, std::ratio< 4 >, std::ratio< 0 >, std::ratio< 2 > >	units::category::capacitance_unit
	Represents an SI derived unit of capacitance.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-3 >, std::ratio< 0 >, std::ratio<-2 > >	units::category::impedance_unit
	Represents an SI derived unit of impedance.
typedef base_unit< detail::meter_ratio<-2 >, std::ratio<-1 >, std::ratio< 3 >, std::ratio< 0 >, std::ratio< 2 > >	units::category::conductance_unit
	Represents an SI derived unit of conductance.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::magnetic_flux_unit
	Represents an SI derived unit of magnetic flux.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::magnetic_field_strength_unit
	Represents an SI derived unit of magnetic field strength.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 >, std::ratio< 0 >, std::ratio<-2 > >	units::category::inductance_unit
	Represents an SI derived unit of inductance.
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 > >	units::category::luminous_flux_unit
	Represents an SI derived unit of luminous flux.
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 > >	units::category::illuminance_unit
	Represents an SI derived unit of illuminance.
typedef base_unit< detail::meter_ratio< 0 >, std::ratio< 0 >, std::ratio<-1 > >	units::category::radioactivity_unit
	Represents an SI derived unit of radioactivity.
typedef base_unit< detail::meter_ratio< 2 >, std::ratio< 1 >, std::ratio<-2 > >	units::category::torque_unit
	Represents an SI derived unit of torque.
typedef base_unit< detail::meter_ratio< 2 > >	units::category::area_unit
	Represents an SI derived unit of area.
typedef base_unit< detail::meter_ratio< 3 > >	units::category::volume_unit
	Represents an SI derived unit of volume.
typedef base_unit< detail::meter_ratio<-3 >, std::ratio< 1 > >	units::category::density_unit
	Represents an SI derived unit of density.
typedef base_unit	units::category::concentration_unit
	Represents a unit of concentration.
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 > >	units::category::data_unit
	Represents a unit of data size.
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 > >	units::category::data_transfer_rate_unit
	Represents a unit of data transfer rate.
template<class U>
using	units::traits::base_unit_of = typename units::detail::base_unit_of_impl<U>::type
	Trait which returns the base_unit type that a unit is originally derived from.
template<class U>
using	units::inverse = typename units::detail::inverse_impl<U>::type
	represents the inverse unit type of class U.
template<class U>
using	units::squared = typename units::detail::squared_impl<U>::type
	represents the unit type of class U squared
template<class U>
using	units::cubed = typename units::detail::cubed_impl<U>::type
	represents the type of class U cubed.
template<typename Ratio, std::intmax_t Eps = 10000000000>
using	units::ratio_sqrt = typename units::detail::Sqrt<Ratio, std::ratio<1, Eps>>::type
	Calculate square root of a ratio at compile-time.
template<class U, std::intmax_t Eps = 10000000000>
using	units::square_root = typename units::detail::sqrt_impl<U, Eps>::type
	represents the square root of type class U.
template<class U, class... Us>
using	units::compound_unit = typename units::detail::compound_impl<U, Us...>::type
	Represents a unit type made up from other units.
typedef unit< std::ratio< 1 >, units::category::scalar_unit >	units::dimensionless::scalar
typedef unit< std::ratio< 1 >, units::category::dimensionless_unit >	units::dimensionless::dimensionless
typedef unit_t< scalar >	units::dimensionless::scalar_t
typedef scalar_t	units::dimensionless::dimensionless_t
typedef unit_t< scalar, double, decibel_scale >	units::dimensionless::dB_t
typedef dB_t	units::dimensionless::dBi_t
template<class U>
using	units::atto = typename units::detail::prefix<std::atto, U>::type
	Represents the type of class U with the metric 'atto' prefix appended.
template<class U>
using	units::femto = typename units::detail::prefix<std::femto,U>::type
	Represents the type of class U with the metric 'femto' prefix appended.
template<class U>
using	units::pico = typename units::detail::prefix<std::pico, U>::type
	Represents the type of class U with the metric 'pico' prefix appended.
template<class U>
using	units::nano = typename units::detail::prefix<std::nano, U>::type
	Represents the type of class U with the metric 'nano' prefix appended.
template<class U>
using	units::micro = typename units::detail::prefix<std::micro,U>::type
	Represents the type of class U with the metric 'micro' prefix appended.
template<class U>
using	units::milli = typename units::detail::prefix<std::milli,U>::type
	Represents the type of class U with the metric 'milli' prefix appended.
template<class U>
using	units::centi = typename units::detail::prefix<std::centi,U>::type
	Represents the type of class U with the metric 'centi' prefix appended.
template<class U>
using	units::deci = typename units::detail::prefix<std::deci, U>::type
	Represents the type of class U with the metric 'deci' prefix appended.
template<class U>
using	units::deca = typename units::detail::prefix<std::deca, U>::type
	Represents the type of class U with the metric 'deca' prefix appended.
template<class U>
using	units::hecto = typename units::detail::prefix<std::hecto,U>::type
	Represents the type of class U with the metric 'hecto' prefix appended.
template<class U>
using	units::kilo = typename units::detail::prefix<std::kilo, U>::type
	Represents the type of class U with the metric 'kilo' prefix appended.
template<class U>
using	units::mega = typename units::detail::prefix<std::mega, U>::type
	Represents the type of class U with the metric 'mega' prefix appended.
template<class U>
using	units::giga = typename units::detail::prefix<std::giga, U>::type
	Represents the type of class U with the metric 'giga' prefix appended.
template<class U>
using	units::tera = typename units::detail::prefix<std::tera, U>::type
	Represents the type of class U with the metric 'tera' prefix appended.
template<class U>
using	units::peta = typename units::detail::prefix<std::peta, U>::type
	Represents the type of class U with the metric 'peta' prefix appended.
template<class U>
using	units::exa = typename units::detail::prefix<std::exa, U>::type
	Represents the type of class U with the metric 'exa' prefix appended.
template<class U>
using	units::kibi = typename units::detail::prefix<std::ratio<1024>, U>::type
	Represents the type of class U with the binary 'kibi' prefix appended.
template<class U>
using	units::mebi = typename units::detail::prefix<std::ratio<1048576>, U>::type
	Represents the type of class U with the binary 'mibi' prefix appended.
template<class U>
using	units::gibi = typename units::detail::prefix<std::ratio<1073741824>, U>::type
	Represents the type of class U with the binary 'gibi' prefix appended.
template<class U>
using	units::tebi = typename units::detail::prefix<std::ratio<1099511627776>, U>::type
	Represents the type of class U with the binary 'tebi' prefix appended.
template<class U>
using	units::pebi = typename units::detail::prefix<std::ratio<1125899906842624>, U>::type
	Represents the type of class U with the binary 'pebi' prefix appended.
template<class U>
using	units::exbi = typename units::detail::prefix<std::ratio<1152921504606846976>, U>::type
	Represents the type of class U with the binary 'exbi' prefix appended.
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::length_unit >	units::length::meters
Units (full names singular)
typedef meters	units::length::meter
Units (abbreviated)
typedef meters	units::length::m
Unit Containers
typedef unit_t< meter >	units::length::meter_t
typedef unit_t< foot >	units::length::foot_t
typedef unit_t< inch >	units::length::inch_t
typedef unit_t< mil >	units::length::mil_t
typedef unit_t< mile >	units::length::mile_t
typedef unit_t< nauticalMile >	units::length::nauticalMile_t
typedef unit_t< astronicalUnit >	units::length::astronicalUnit_t
typedef unit_t< lightyear >	units::length::lightyear_t
typedef unit_t< parsec >	units::length::parsec_t
typedef unit_t< angstrom >	units::length::angstrom_t
typedef unit_t< cubit >	units::length::cubit_t
typedef unit_t< fathom >	units::length::fathom_t
typedef unit_t< chain >	units::length::chain_t
typedef unit_t< furlong >	units::length::furlong_t
typedef unit_t< hand >	units::length::hand_t
typedef unit_t< league >	units::length::league_t
typedef unit_t< nauticalLeague >	units::length::nauticalLeague_t
typedef unit_t< yard >	units::length::yard_t
Units (full names plural)
typedef unit< std::ratio< 1, 1000 >, units::category::mass_unit >	units::mass::grams
Units (full names singular)
typedef grams	units::mass::gram
Units (abbreviated)
typedef grams	units::mass::g
Unit Containers
typedef unit_t< gram >	units::mass::gram_t
typedef unit_t< metric_ton >	units::mass::metric_ton_t
typedef unit_t< pound >	units::mass::pound_t
typedef unit_t< long_ton >	units::mass::long_ton_t
typedef unit_t< short_ton >	units::mass::short_ton_t
typedef unit_t< stone >	units::mass::stone_t
typedef unit_t< ounce >	units::mass::ounce_t
typedef unit_t< carat >	units::mass::carat_t
typedef unit_t< slug >	units::mass::slug_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::time_unit >	units::time::seconds
Units (full names singular)
typedef seconds	units::time::second
Units (abbreviated)
typedef seconds	units::time::s
Unit Containers
typedef unit_t< second >	units::time::second_t
typedef unit_t< minute >	units::time::minute_t
typedef unit_t< hour >	units::time::hour_t
typedef unit_t< day >	units::time::day_t
typedef unit_t< week >	units::time::week_t
typedef unit_t< year >	units::time::year_t
typedef unit_t< julian_year >	units::time::julian_year_t
typedef unit_t< gregorian_year >	units::time::gregorian_year_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::angle_unit >	units::angle::radians
Units (full names singular)
typedef radians	units::angle::radian
Units (abbreviated)
typedef radians	units::angle::rad
Unit Containers
typedef unit_t< radian >	units::angle::radian_t
typedef unit_t< degree >	units::angle::degree_t
typedef unit_t< arcminute >	units::angle::arcminute_t
typedef unit_t< arcsecond >	units::angle::arcsecond_t
typedef unit_t< milliarcsecond >	units::angle::milliarcsecond_t
typedef unit_t< turn >	units::angle::turn_t
typedef unit_t< gradian >	units::angle::gradian_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::current_unit >	units::current::amperes
Units (full names singular)
typedef amperes	units::current::ampere
Units (abbreviated)
typedef amperes	units::current::A
Unit Containers
typedef unit_t< ampere >	units::current::ampere_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::temperature_unit >	units::temperature::kelvin
Units (abbreviated)
typedef kelvin	units::temperature::K
Unit Containers
typedef unit_t< kelvin >	units::temperature::kelvin_t
typedef unit_t< celsius >	units::temperature::celsius_t
typedef unit_t< fahrenheit >	units::temperature::fahrenheit_t
typedef unit_t< reaumur >	units::temperature::reaumur_t
typedef unit_t< rankine >	units::temperature::rankine_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::substance_unit >	units::substance::moles
Units (full names singular)
typedef moles	units::substance::mole
Units (abbreviated)
typedef moles	units::substance::mol
Unit Containers
typedef unit_t< mole >	units::substance::mole_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::luminous_intensity_unit >	units::luminous_intensity::candelas
Units (full names singular)
typedef candelas	units::luminous_intensity::candela
Units (abbreviated)
typedef candelas	units::luminous_intensity::cd
Unit Containers
typedef unit_t< candela >	units::luminous_intensity::candela_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::solid_angle_unit >	units::solid_angle::steradians
Units (full names singular)
typedef steradians	units::solid_angle::steradian
Units (abbreviated)
typedef steradians	units::solid_angle::sr
Unit Containers
typedef unit_t< steradian >	units::solid_angle::steradian_t
typedef unit_t< degree_squared >	units::solid_angle::degree_squared_t
typedef unit_t< spat >	units::solid_angle::spat_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::frequency_unit >	units::frequency::hertz
Units (abbreviated)
typedef hertz	units::frequency::Hz
Unit Containers
typedef unit_t< hertz >	units::frequency::hertz_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::velocity_unit >	units::velocity::meters_per_second
Units (abbreviated)
typedef meters_per_second	units::velocity::mps
Unit Containers
typedef unit_t< meters_per_second >	units::velocity::meters_per_second_t
typedef unit_t< feet_per_second >	units::velocity::feet_per_second_t
typedef unit_t< miles_per_hour >	units::velocity::miles_per_hour_t
typedef unit_t< kilometers_per_hour >	units::velocity::kilometers_per_hour_t
typedef unit_t< knot >	units::velocity::knot_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::angular_velocity_unit >	units::angular_velocity::radians_per_second
Units (abbreviated)
typedef radians_per_second	units::angular_velocity::rad_per_s
Unit Containers
typedef unit_t< radians_per_second >	units::angular_velocity::radians_per_second_t
typedef unit_t< degrees_per_second >	units::angular_velocity::degrees_per_second_t
typedef unit_t< revolutions_per_minute >	units::angular_velocity::revolutions_per_minute_t
typedef unit_t< revolutions_per_second >	units::angular_velocity::revolutions_per_second_t
typedef unit_t< milliarcseconds_per_year >	units::angular_velocity::milliarcseconds_per_year_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::acceleration_unit >	units::acceleration::meters_per_second_squared
Units (abbreviated)
typedef meters_per_second_squared	units::acceleration::mps_sq
Unit Containers
typedef unit_t< meters_per_second_squared >	units::acceleration::meters_per_second_squared_t
typedef unit_t< feet_per_second_squared >	units::acceleration::feet_per_second_squared_t
typedef unit_t< standard_gravity >	units::acceleration::standard_gravity_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::jerk_unit >	units::jerk::meters_per_second_cubed
Units (abbreviated)
typedef meters_per_second_cubed	units::jerk::mps_cb
Unit Containers
typedef unit_t< meters_per_second_cubed >	units::jerk::meters_per_second_cubed_t
typedef unit_t< feet_per_second_cubed >	units::jerk::feet_per_second_cubed_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::force_unit >	units::force::newtons
Units (full names singular)
typedef newtons	units::force::newton
Units (abbreviated)
typedef newtons	units::force::N
Unit Containers
typedef unit_t< newton >	units::force::newton_t
typedef unit_t< pound >	units::force::pound_t
typedef unit_t< dyne >	units::force::dyne_t
typedef unit_t< kilopond >	units::force::kilopond_t
typedef unit_t< poundal >	units::force::poundal_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::pressure_unit >	units::pressure::pascals
Units (full names singular)
typedef pascals	units::pressure::pascal
Units (abbreviated)
typedef pascals	units::pressure::Pa
Unit Containers
typedef unit_t< pascal >	units::pressure::pascal_t
typedef unit_t< bar >	units::pressure::bar_t
typedef unit_t< mbar >	units::pressure::mbar_t
typedef unit_t< atmosphere >	units::pressure::atmosphere_t
typedef unit_t< pounds_per_square_inch >	units::pressure::pounds_per_square_inch_t
typedef unit_t< torr >	units::pressure::torr_t
typedef unit_t< millimeter_of_mercury >	units::pressure::millimeter_of_mercury_t
typedef unit_t< inch_of_mercury >	units::pressure::inch_of_mercury_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::charge_unit >	units::charge::coulombs
Units (full names singular)
typedef coulombs	units::charge::coulomb
Units (abbreviated)
typedef coulombs	units::charge::C
Unit Containers
typedef unit_t< coulomb >	units::charge::coulomb_t
typedef unit_t< ampere_hour >	units::charge::ampere_hour_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::energy_unit >	units::energy::joules
Units (full names singular)
typedef joules	units::energy::joule
Units (abbreviated)
typedef joules	units::energy::J
Unit Containers
typedef unit_t< joule >	units::energy::joule_t
typedef unit_t< calorie >	units::energy::calorie_t
typedef unit_t< kilowatt_hour >	units::energy::kilowatt_hour_t
typedef unit_t< watt_hour >	units::energy::watt_hour_t
typedef unit_t< british_thermal_unit >	units::energy::british_thermal_unit_t
typedef unit_t< british_thermal_unit_iso >	units::energy::british_thermal_unit_iso_t
typedef unit_t< british_thermal_unit_59 >	units::energy::british_thermal_unit_59_t
typedef unit_t< therm >	units::energy::therm_t
typedef unit_t< foot_pound >	units::energy::foot_pound_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::power_unit >	units::power::watts
Units (full names singular)
typedef watts	units::power::watt
Units (abbreviated)
typedef watts	units::power::W
Unit Containers
typedef unit_t< watt >	units::power::watt_t
typedef unit_t< horsepower >	units::power::horsepower_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::voltage_unit >	units::voltage::volts
Units (full names singular)
typedef volts	units::voltage::volt
Units (abbreviated)
typedef volts	units::voltage::V
Unit Containers
typedef unit_t< volt >	units::voltage::volt_t
typedef unit_t< statvolt >	units::voltage::statvolt_t
typedef unit_t< abvolt >	units::voltage::abvolt_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::capacitance_unit >	units::capacitance::farads
Units (full names singular)
typedef farads	units::capacitance::farad
Units (abbreviated)
typedef farads	units::capacitance::F
Unit Containers
typedef unit_t< farad >	units::capacitance::farad_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::impedance_unit >	units::impedance::ohms
Units (full names singular)
typedef ohms	units::impedance::ohm
Units (abbreviated)
typedef ohms	units::impedance::Ohm
Unit Containers
typedef unit_t< ohm >	units::impedance::ohm_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::conductance_unit >	units::conductance::siemens
Units (abbreviated)
typedef siemens	units::conductance::S
Unit Containers
typedef unit_t< siemens >	units::conductance::siemens_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::magnetic_flux_unit >	units::magnetic_flux::webers
Units (full names singular)
typedef webers	units::magnetic_flux::weber
Units (abbreviated)
typedef webers	units::magnetic_flux::Wb
Unit Containers
typedef unit_t< weber >	units::magnetic_flux::weber_t
typedef unit_t< maxwell >	units::magnetic_flux::maxwell_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::magnetic_field_strength_unit >	units::magnetic_field_strength::teslas
Units (full names singular)
typedef teslas	units::magnetic_field_strength::tesla
Units (abbreviated)
typedef teslas	units::magnetic_field_strength::Te
Unit Containers
typedef unit_t< tesla >	units::magnetic_field_strength::tesla_t
typedef unit_t< gauss >	units::magnetic_field_strength::gauss_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::inductance_unit >	units::inductance::henries
Units (full names singular)
typedef henries	units::inductance::henry
Units (abbreviated)
typedef henries	units::inductance::H
Unit Containers
typedef unit_t< henry >	units::inductance::henry_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::luminous_flux_unit >	units::luminous_flux::lumens
Units (full names singular)
typedef lumens	units::luminous_flux::lumen
Units (abbreviated)
typedef lumens	units::luminous_flux::lm
Unit Containers
typedef unit_t< lumen >	units::luminous_flux::lumen_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::illuminance_unit >	units::illuminance::luxes
Units (full names singular)
typedef luxes	units::illuminance::lux
Units (abbreviated)
typedef luxes	units::illuminance::lx
Unit Containers
typedef unit_t< lux >	units::illuminance::lux_t
typedef unit_t< footcandle >	units::illuminance::footcandle_t
typedef unit_t< lumens_per_square_inch >	units::illuminance::lumens_per_square_inch_t
typedef unit_t< phot >	units::illuminance::phot_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::frequency::hertz >	units::radiation::becquerels
Units (full names singular)
typedef becquerels	units::radiation::becquerel
Units (abbreviated)
typedef becquerels	units::radiation::Bq
Unit Containers
typedef unit_t< becquerel >	units::radiation::becquerel_t
typedef unit_t< gray >	units::radiation::gray_t
typedef unit_t< sievert >	units::radiation::sievert_t
typedef unit_t< curie >	units::radiation::curie_t
typedef unit_t< rutherford >	units::radiation::rutherford_t
typedef unit_t< rad >	units::radiation::rad_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::energy::joule >	units::torque::newton_meters
Units (full names singular)
typedef newton_meters	units::torque::newton_meter
Units (abbreviated)
typedef newton_meters	units::torque::Nm
Unit Containers
typedef unit_t< newton_meter >	units::torque::newton_meter_t
typedef unit_t< foot_pound >	units::torque::foot_pound_t
typedef unit_t< foot_poundal >	units::torque::foot_poundal_t
typedef unit_t< inch_pound >	units::torque::inch_pound_t
typedef unit_t< meter_kilogram >	units::torque::meter_kilogram_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::area_unit >	units::area::square_meters
Units (full names singular)
typedef square_meters	units::area::square_meter
Units (abbreviated)
typedef square_meters	units::area::sq_m
Unit Containers
typedef unit_t< square_meter >	units::area::square_meter_t
typedef unit_t< square_foot >	units::area::square_foot_t
typedef unit_t< square_inch >	units::area::square_inch_t
typedef unit_t< square_mile >	units::area::square_mile_t
typedef unit_t< square_kilometer >	units::area::square_kilometer_t
typedef unit_t< hectare >	units::area::hectare_t
typedef unit_t< acre >	units::area::acre_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::volume_unit >	units::volume::cubic_meters
Units (full names singular)
typedef cubic_meters	units::volume::cubic_meter
Units (abbreviated)
typedef cubic_meters	units::volume::cu_m
Unit Containers
typedef unit_t< cubic_meter >	units::volume::cubic_meter_t
typedef unit_t< cubic_millimeter >	units::volume::cubic_millimeter_t
typedef unit_t< cubic_kilometer >	units::volume::cubic_kilometer_t
typedef unit_t< liter >	units::volume::liter_t
typedef unit_t< cubic_inch >	units::volume::cubic_inch_t
typedef unit_t< cubic_foot >	units::volume::cubic_foot_t
typedef unit_t< cubic_yard >	units::volume::cubic_yard_t
typedef unit_t< cubic_mile >	units::volume::cubic_mile_t
typedef unit_t< gallon >	units::volume::gallon_t
typedef unit_t< quart >	units::volume::quart_t
typedef unit_t< pint >	units::volume::pint_t
typedef unit_t< cup >	units::volume::cup_t
typedef unit_t< fluid_ounce >	units::volume::fluid_ounce_t
typedef unit_t< barrel >	units::volume::barrel_t
typedef unit_t< bushel >	units::volume::bushel_t
typedef unit_t< cord >	units::volume::cord_t
typedef unit_t< cubic_fathom >	units::volume::cubic_fathom_t
typedef unit_t< tablespoon >	units::volume::tablespoon_t
typedef unit_t< teaspoon >	units::volume::teaspoon_t
typedef unit_t< pinch >	units::volume::pinch_t
typedef unit_t< dash >	units::volume::dash_t
typedef unit_t< drop >	units::volume::drop_t
typedef unit_t< fifth >	units::volume::fifth_t
typedef unit_t< dram >	units::volume::dram_t
typedef unit_t< gill >	units::volume::gill_t
typedef unit_t< peck >	units::volume::peck_t
typedef unit_t< sack >	units::volume::sack_t
typedef unit_t< shot >	units::volume::shot_t
typedef unit_t< strike >	units::volume::strike_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::density_unit >	units::density::kilograms_per_cubic_meter
Units (abbreviated)
typedef kilograms_per_cubic_meter	units::density::kg_per_cu_m
Unit Containers
typedef unit_t< kilograms_per_cubic_meter >	units::density::kilograms_per_cubic_meter_t
typedef unit_t< grams_per_milliliter >	units::density::grams_per_milliliter_t
typedef unit_t< kilograms_per_liter >	units::density::kilograms_per_liter_t
typedef unit_t< ounces_per_cubic_foot >	units::density::ounces_per_cubic_foot_t
typedef unit_t< ounces_per_cubic_inch >	units::density::ounces_per_cubic_inch_t
typedef unit_t< ounces_per_gallon >	units::density::ounces_per_gallon_t
typedef unit_t< pounds_per_cubic_foot >	units::density::pounds_per_cubic_foot_t
typedef unit_t< pounds_per_cubic_inch >	units::density::pounds_per_cubic_inch_t
typedef unit_t< pounds_per_gallon >	units::density::pounds_per_gallon_t
typedef unit_t< slugs_per_cubic_foot >	units::density::slugs_per_cubic_foot_t
Units (full names plural)
typedef unit< std::ratio< 1, 1000000 >, units::category::scalar_unit >	units::concentration::parts_per_million
Units (full names singular)
typedef parts_per_million	units::concentration::ppm
Unit Containers
typedef unit_t< ppm >	units::concentration::ppm_t
typedef unit_t< ppb >	units::concentration::ppb_t
typedef unit_t< ppt >	units::concentration::ppt_t
typedef unit_t< percent >	units::concentration::percent_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::data_unit >	units::data::bytes
Units (full names singular)
typedef bytes	units::data::byte
Units (abbreviated)
typedef bytes	units::data::B
Unit Containers
typedef unit_t< byte >	units::data::byte_t
typedef unit_t< exabyte >	units::data::exabyte_t
typedef unit_t< bit >	units::data::bit_t
typedef unit_t< exabit >	units::data::exabit_t
Units (full names plural)
typedef unit< std::ratio< 1 >, units::category::data_transfer_rate_unit >	units::data_transfer_rate::bytes_per_second
Units (abbreviated)
typedef bytes_per_second	units::data_transfer_rate::Bps
Unit Containers
typedef unit_t< bytes_per_second >	units::data_transfer_rate::bytes_per_second_t
typedef unit_t< exabytes_per_second >	units::data_transfer_rate::exabytes_per_second_t
typedef unit_t< bits_per_second >	units::data_transfer_rate::bits_per_second_t
typedef unit_t< exabits_per_second >	units::data_transfer_rate::exabits_per_second_t

Functions
template<typename T>
std::string	units::detail::to_string (const T &t)
template<typename T>
constexpr const char *	units::name (const T &)
template<typename T>
constexpr const char *	units::name_plural (const T &)
template<typename T>
constexpr const char *	units::abbreviation (const T &)
template<class UnitFrom, class UnitTo, typename T = double>
static constexpr T	units::convert (const T &value) noexcept
	converts a value from one type to another.
template<class UnitType, typename T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
constexpr UnitType	units::make_unit (const T value) noexcept
	Constructs a unit container from an arithmetic type.
template<class Units, typename T, template< typename > class NonLinearScale>
std::ostream &	units::operator<< (std::ostream &os, const unit_t< Units, T, NonLinearScale > &obj) noexcept
template<class Units, typename T, template< typename > class NonLinearScale, typename RhsType>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator+= (unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
template<class Units, typename T, template< typename > class NonLinearScale, typename RhsType>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator-= (unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
template<class Units, typename T, template< typename > class NonLinearScale, typename RhsType>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator*= (unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
template<class Units, typename T, template< typename > class NonLinearScale, typename RhsType>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator/= (unit_t< Units, T, NonLinearScale > &lhs, const RhsType &rhs) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	units::operator+ (const unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator++ (unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	units::operator++ (unit_t< Units, T, NonLinearScale > &u, int) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	units::operator- (const unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale > &	units::operator-- (unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	units::operator-- (unit_t< Units, T, NonLinearScale > &u, int) noexcept
template<typename T, typename Units, class = std::enable_if_t<std::is_arithmetic<T>::value && traits::is_unit_t<Units>::value>>
constexpr T	units::unit_cast (const Units &value) noexcept
	Casts a unit container to an arithmetic type.
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t<!traits::is_same_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr int	units::operator+ (const UnitTypeLhs &, const UnitTypeRhs &) noexcept
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< traits::has_linear_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator+ (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Addition operator for unit_t types with a linear_scale.
template<typename T, std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>
constexpr dimensionless::scalar_t	units::operator+ (const dimensionless::scalar_t &lhs, T rhs) noexcept
	Addition operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.
template<typename T, std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>
constexpr dimensionless::scalar_t	units::operator+ (T lhs, const dimensionless::scalar_t &rhs) noexcept
	Addition operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< traits::has_linear_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator- (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Subtraction operator for unit_t types with a linear_scale.
template<typename T, std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>
constexpr dimensionless::scalar_t	units::operator- (const dimensionless::scalar_t &lhs, T rhs) noexcept
	Subtraction operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.
template<typename T, std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>
constexpr dimensionless::scalar_t	units::operator- (T lhs, const dimensionless::scalar_t &rhs) noexcept
	Subtraction operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.
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>
constexpr auto	units::operator* (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept -> unit_t< compound_unit< squared< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type > > >
	Multiplication type for convertible unit_t types with a linear scale.
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>
constexpr auto	units::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 > >
	Multiplication type for non-convertible unit_t types with a linear scale.
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>
constexpr UnitTypeLhs	units::operator* (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Multiplication by a dimensionless unit for unit_t types with a linear scale.
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>
constexpr UnitTypeRhs	units::operator* (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Multiplication by a dimensionless unit for unit_t types with a linear scale.
template<class UnitTypeLhs, typename T, std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeLhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator* (const UnitTypeLhs &lhs, T rhs) noexcept
	Multiplication by a scalar for unit_t types with a linear scale.
template<class UnitTypeRhs, typename T, std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeRhs >::value, int > = 0>
constexpr UnitTypeRhs	units::operator* (T lhs, const UnitTypeRhs &rhs) noexcept
	Multiplication by a scalar for unit_t types with a linear scale.
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>
constexpr dimensionless::scalar_t	units::operator/ (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Division for convertible unit_t types with a linear scale.
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>
constexpr auto	units::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 > > >
	Division for non-convertible unit_t types with a linear scale.
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>
constexpr UnitTypeLhs	units::operator/ (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept
	Division by a dimensionless unit for unit_t types with a linear scale.
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>
constexpr auto	units::operator/ (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept -> unit_t< inverse< typename units::traits::unit_t_traits< UnitTypeRhs >::unit_type > >
	Division of a dimensionless unit by a unit_t type with a linear scale.
template<class UnitTypeLhs, typename T, std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeLhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator/ (const UnitTypeLhs &lhs, T rhs) noexcept
	Division by a scalar for unit_t types with a linear scale.
template<class UnitTypeRhs, typename T, std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeRhs >::value, int > = 0>
constexpr auto	units::operator/ (T lhs, const UnitTypeRhs &rhs) noexcept -> unit_t< inverse< typename units::traits::unit_t_traits< UnitTypeRhs >::unit_type > >
	Division of a scalar by a unit_t type with a linear scale.
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator== (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator== (const Units &lhs, const double rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator!= (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator!= (const Units &lhs, const double rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator>= (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator>= (const Units &lhs, const double rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator> (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator> (const Units &lhs, const double rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator<= (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator<= (const Units &lhs, const double rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator< (const double lhs, const Units &rhs) noexcept
template<typename Units, class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	units::operator< (const Units &lhs, const double rhs) noexcept
template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value, int>>
auto	units::math::pow (const UnitType &value) noexcept -> unit_t< typename units::detail::power_of_unit< power, typename units::traits::unit_t_traits< UnitType >::unit_type >::type, typename units::traits::unit_t_traits< UnitType >::underlying_type, linear_scale >
	computes the value of value raised to the power
template<int power, class UnitType, class = typename std::enable_if<traits::has_linear_scale<UnitType>::value, int>>
constexpr auto	units::math::cpow (const UnitType &value) noexcept -> unit_t< typename units::detail::power_of_unit< power, typename units::traits::unit_t_traits< UnitType >::unit_type >::type, typename units::traits::unit_t_traits< UnitType >::underlying_type, linear_scale >
	computes the value of value raised to the power as a constexpr
std::ostream &	units::dimensionless::operator<< (std::ostream &os, const dB_t &obj)
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr auto	units::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 >
	Addition for convertible unit_t types with a decibel_scale.
template<class UnitTypeLhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs >::value &&!traits::is_dimensionless_unit< UnitTypeLhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator+ (const UnitTypeLhs &lhs, const dimensionless::dB_t &rhs) noexcept
	Addition between unit_t types with a decibel_scale and dimensionless dB units.
template<class UnitTypeRhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>
constexpr UnitTypeRhs	units::operator+ (const dimensionless::dB_t &lhs, const UnitTypeRhs &rhs) noexcept
	Addition between unit_t types with a decibel_scale and dimensionless dB units.
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr auto	units::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 >
	Subtraction for convertible unit_t types with a decibel_scale.
template<class UnitTypeLhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs >::value &&!traits::is_dimensionless_unit< UnitTypeLhs >::value, int > = 0>
constexpr UnitTypeLhs	units::operator- (const UnitTypeLhs &lhs, const dimensionless::dB_t &rhs) noexcept
	Subtraction between unit_t types with a decibel_scale and dimensionless dB units.
template<class UnitTypeRhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>
constexpr auto	units::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 >
	Subtraction between unit_t types with a decibel_scale and dimensionless dB units.
template<>
constexpr const char *	units::name (const length::meter_t &)
template<>
constexpr const char *	units::abbreviation (const length::meter_t &)
template<>
constexpr const char *	units::name_plural (const length::meter_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const meter_t &obj)
std::string	units::length::to_string (const meter_t &obj)
	units::UNIT_ADD_LITERALS (length, meter, m) UNIT_ADD(length
femto< meters >	units::UNIT_ADD (length, picometer, picometers, pm, pico< meters >) UNIT_ADD(length
femto< meters > nano< meters >	units::UNIT_ADD (length, micrometer, micrometers, um, micro< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters >	units::UNIT_ADD (length, centimeter, centimeters, cm, centi< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters >	units::UNIT_ADD (length, decameter, decameters, dam, deca< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters >	units::UNIT_ADD (length, kilometer, kilometers, km, kilo< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters > mega< meters >	units::UNIT_ADD (length, gigameter, gigameters, Gm, giga< meters >) UNIT_ADD(length
template<>
constexpr const char *	units::name (const length::foot_t &)
template<>
constexpr const char *	units::abbreviation (const length::foot_t &)
template<>
constexpr const char *	units::name_plural (const length::foot_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const foot_t &obj)
std::string	units::length::to_string (const foot_t &obj)
template<>
constexpr const char *	units::name (const length::inch_t &)
template<>
constexpr const char *	units::abbreviation (const length::inch_t &)
template<>
constexpr const char *	units::name_plural (const length::inch_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const inch_t &obj)
std::string	units::length::to_string (const inch_t &obj)
template<>
constexpr const char *	units::name (const length::mil_t &)
template<>
constexpr const char *	units::abbreviation (const length::mil_t &)
template<>
constexpr const char *	units::name_plural (const length::mil_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const mil_t &obj)
std::string	units::length::to_string (const mil_t &obj)
template<>
constexpr const char *	units::name (const length::mile_t &)
template<>
constexpr const char *	units::abbreviation (const length::mile_t &)
template<>
constexpr const char *	units::name_plural (const length::mile_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const mile_t &obj)
std::string	units::length::to_string (const mile_t &obj)
template<>
constexpr const char *	units::name (const length::nauticalMile_t &)
template<>
constexpr const char *	units::abbreviation (const length::nauticalMile_t &)
template<>
constexpr const char *	units::name_plural (const length::nauticalMile_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const nauticalMile_t &obj)
std::string	units::length::to_string (const nauticalMile_t &obj)
template<>
constexpr const char *	units::name (const length::astronicalUnit_t &)
template<>
constexpr const char *	units::abbreviation (const length::astronicalUnit_t &)
template<>
constexpr const char *	units::name_plural (const length::astronicalUnit_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const astronicalUnit_t &obj)
std::string	units::length::to_string (const astronicalUnit_t &obj)
template<>
constexpr const char *	units::name (const length::lightyear_t &)
template<>
constexpr const char *	units::abbreviation (const length::lightyear_t &)
template<>
constexpr const char *	units::name_plural (const length::lightyear_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const lightyear_t &obj)
std::string	units::length::to_string (const lightyear_t &obj)
template<>
constexpr const char *	units::name (const length::parsec_t &)
template<>
constexpr const char *	units::abbreviation (const length::parsec_t &)
template<>
constexpr const char *	units::name_plural (const length::parsec_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const parsec_t &obj)
std::string	units::length::to_string (const parsec_t &obj)
template<>
constexpr const char *	units::name (const length::angstrom_t &)
template<>
constexpr const char *	units::abbreviation (const length::angstrom_t &)
template<>
constexpr const char *	units::name_plural (const length::angstrom_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const angstrom_t &obj)
std::string	units::length::to_string (const angstrom_t &obj)
template<>
constexpr const char *	units::name (const length::cubit_t &)
template<>
constexpr const char *	units::abbreviation (const length::cubit_t &)
template<>
constexpr const char *	units::name_plural (const length::cubit_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const cubit_t &obj)
std::string	units::length::to_string (const cubit_t &obj)
template<>
constexpr const char *	units::name (const length::fathom_t &)
template<>
constexpr const char *	units::abbreviation (const length::fathom_t &)
template<>
constexpr const char *	units::name_plural (const length::fathom_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const fathom_t &obj)
std::string	units::length::to_string (const fathom_t &obj)
template<>
constexpr const char *	units::name (const length::chain_t &)
template<>
constexpr const char *	units::abbreviation (const length::chain_t &)
template<>
constexpr const char *	units::name_plural (const length::chain_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const chain_t &obj)
std::string	units::length::to_string (const chain_t &obj)
template<>
constexpr const char *	units::name (const length::furlong_t &)
template<>
constexpr const char *	units::abbreviation (const length::furlong_t &)
template<>
constexpr const char *	units::name_plural (const length::furlong_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const furlong_t &obj)
std::string	units::length::to_string (const furlong_t &obj)
template<>
constexpr const char *	units::name (const length::hand_t &)
template<>
constexpr const char *	units::abbreviation (const length::hand_t &)
template<>
constexpr const char *	units::name_plural (const length::hand_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const hand_t &obj)
std::string	units::length::to_string (const hand_t &obj)
template<>
constexpr const char *	units::name (const length::league_t &)
template<>
constexpr const char *	units::abbreviation (const length::league_t &)
template<>
constexpr const char *	units::name_plural (const length::league_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const league_t &obj)
std::string	units::length::to_string (const league_t &obj)
template<>
constexpr const char *	units::name (const length::nauticalLeague_t &)
template<>
constexpr const char *	units::abbreviation (const length::nauticalLeague_t &)
template<>
constexpr const char *	units::name_plural (const length::nauticalLeague_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const nauticalLeague_t &obj)
std::string	units::length::to_string (const nauticalLeague_t &obj)
template<>
constexpr const char *	units::name (const length::yard_t &)
template<>
constexpr const char *	units::abbreviation (const length::yard_t &)
template<>
constexpr const char *	units::name_plural (const length::yard_t &)
std::ostream &	units::length::operator<< (std::ostream &os, const yard_t &obj)
std::string	units::length::to_string (const yard_t &obj)
	units::UNIT_ADD_LITERALS (length, yard, yd) namespace traits
template<>
constexpr const char *	units::name (const mass::gram_t &)
template<>
constexpr const char *	units::abbreviation (const mass::gram_t &)
template<>
constexpr const char *	units::name_plural (const mass::gram_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const gram_t &obj)
std::string	units::mass::to_string (const gram_t &obj)
	units::UNIT_ADD_LITERALS (mass, gram, g) UNIT_ADD(mass
femto< grams >	units::UNIT_ADD (mass, picogram, picograms, pg, pico< grams >) UNIT_ADD(mass
femto< grams > nano< grams >	units::UNIT_ADD (mass, microgram, micrograms, ug, micro< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams >	units::UNIT_ADD (mass, centigram, centigrams, cg, centi< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams >	units::UNIT_ADD (mass, decagram, decagrams, dag, deca< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams >	units::UNIT_ADD (mass, kilogram, kilograms, kg, kilo< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams > mega< grams >	units::UNIT_ADD (mass, gigagram, gigagrams, Gg, giga< grams >) UNIT_ADD(mass
template<>
constexpr const char *	units::name (const mass::metric_ton_t &)
template<>
constexpr const char *	units::abbreviation (const mass::metric_ton_t &)
template<>
constexpr const char *	units::name_plural (const mass::metric_ton_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const metric_ton_t &obj)
std::string	units::mass::to_string (const metric_ton_t &obj)
template<>
constexpr const char *	units::name (const mass::pound_t &)
template<>
constexpr const char *	units::abbreviation (const mass::pound_t &)
template<>
constexpr const char *	units::name_plural (const mass::pound_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const pound_t &obj)
std::string	units::mass::to_string (const pound_t &obj)
template<>
constexpr const char *	units::name (const mass::long_ton_t &)
template<>
constexpr const char *	units::abbreviation (const mass::long_ton_t &)
template<>
constexpr const char *	units::name_plural (const mass::long_ton_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const long_ton_t &obj)
std::string	units::mass::to_string (const long_ton_t &obj)
template<>
constexpr const char *	units::name (const mass::short_ton_t &)
template<>
constexpr const char *	units::abbreviation (const mass::short_ton_t &)
template<>
constexpr const char *	units::name_plural (const mass::short_ton_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const short_ton_t &obj)
std::string	units::mass::to_string (const short_ton_t &obj)
template<>
constexpr const char *	units::name (const mass::stone_t &)
template<>
constexpr const char *	units::abbreviation (const mass::stone_t &)
template<>
constexpr const char *	units::name_plural (const mass::stone_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const stone_t &obj)
std::string	units::mass::to_string (const stone_t &obj)
template<>
constexpr const char *	units::name (const mass::ounce_t &)
template<>
constexpr const char *	units::abbreviation (const mass::ounce_t &)
template<>
constexpr const char *	units::name_plural (const mass::ounce_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const ounce_t &obj)
std::string	units::mass::to_string (const ounce_t &obj)
template<>
constexpr const char *	units::name (const mass::carat_t &)
template<>
constexpr const char *	units::abbreviation (const mass::carat_t &)
template<>
constexpr const char *	units::name_plural (const mass::carat_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const carat_t &obj)
std::string	units::mass::to_string (const carat_t &obj)
template<>
constexpr const char *	units::name (const mass::slug_t &)
template<>
constexpr const char *	units::abbreviation (const mass::slug_t &)
template<>
constexpr const char *	units::name_plural (const mass::slug_t &)
std::ostream &	units::mass::operator<< (std::ostream &os, const slug_t &obj)
std::string	units::mass::to_string (const slug_t &obj)
	units::UNIT_ADD_LITERALS (mass, slug, slug) namespace traits
template<>
constexpr const char *	units::name (const time::second_t &)
template<>
constexpr const char *	units::abbreviation (const time::second_t &)
template<>
constexpr const char *	units::name_plural (const time::second_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const second_t &obj)
std::string	units::time::to_string (const second_t &obj)
	units::UNIT_ADD_LITERALS (time, second, s) UNIT_ADD(time
femto< seconds >	units::UNIT_ADD (time, picosecond, picoseconds, ps, pico< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds >	units::UNIT_ADD (time, microsecond, microseconds, us, micro< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds >	units::UNIT_ADD (time, centisecond, centiseconds, cs, centi< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds >	units::UNIT_ADD (time, decasecond, decaseconds, das, deca< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds >	units::UNIT_ADD (time, kilosecond, kiloseconds, ks, kilo< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds > mega< seconds >	units::UNIT_ADD (time, gigasecond, gigaseconds, Gs, giga< seconds >) UNIT_ADD(time
template<>
constexpr const char *	units::name (const time::minute_t &)
template<>
constexpr const char *	units::abbreviation (const time::minute_t &)
template<>
constexpr const char *	units::name_plural (const time::minute_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const minute_t &obj)
std::string	units::time::to_string (const minute_t &obj)
template<>
constexpr const char *	units::name (const time::hour_t &)
template<>
constexpr const char *	units::abbreviation (const time::hour_t &)
template<>
constexpr const char *	units::name_plural (const time::hour_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const hour_t &obj)
std::string	units::time::to_string (const hour_t &obj)
template<>
constexpr const char *	units::name (const time::day_t &)
template<>
constexpr const char *	units::abbreviation (const time::day_t &)
template<>
constexpr const char *	units::name_plural (const time::day_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const day_t &obj)
std::string	units::time::to_string (const day_t &obj)
template<>
constexpr const char *	units::name (const time::week_t &)
template<>
constexpr const char *	units::abbreviation (const time::week_t &)
template<>
constexpr const char *	units::name_plural (const time::week_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const week_t &obj)
std::string	units::time::to_string (const week_t &obj)
template<>
constexpr const char *	units::name (const time::year_t &)
template<>
constexpr const char *	units::abbreviation (const time::year_t &)
template<>
constexpr const char *	units::name_plural (const time::year_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const year_t &obj)
std::string	units::time::to_string (const year_t &obj)
template<>
constexpr const char *	units::name (const time::julian_year_t &)
template<>
constexpr const char *	units::abbreviation (const time::julian_year_t &)
template<>
constexpr const char *	units::name_plural (const time::julian_year_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const julian_year_t &obj)
std::string	units::time::to_string (const julian_year_t &obj)
template<>
constexpr const char *	units::name (const time::gregorian_year_t &)
template<>
constexpr const char *	units::abbreviation (const time::gregorian_year_t &)
template<>
constexpr const char *	units::name_plural (const time::gregorian_year_t &)
std::ostream &	units::time::operator<< (std::ostream &os, const gregorian_year_t &obj)
std::string	units::time::to_string (const gregorian_year_t &obj)
	units::UNIT_ADD_LITERALS (time, gregorian_year, a_g) namespace traits
template<>
constexpr const char *	units::name (const angle::radian_t &)
template<>
constexpr const char *	units::abbreviation (const angle::radian_t &)
template<>
constexpr const char *	units::name_plural (const angle::radian_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const radian_t &obj)
std::string	units::angle::to_string (const radian_t &obj)
	units::UNIT_ADD_LITERALS (angle, radian, rad) UNIT_ADD(angle
femto< radians >	units::UNIT_ADD (angle, picoradian, picoradians, prad, pico< radians >) UNIT_ADD(angle
femto< radians > nano< radians >	units::UNIT_ADD (angle, microradian, microradians, urad, micro< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians >	units::UNIT_ADD (angle, centiradian, centiradians, crad, centi< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians >	units::UNIT_ADD (angle, decaradian, decaradians, darad, deca< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians >	units::UNIT_ADD (angle, kiloradian, kiloradians, krad, kilo< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians > mega< radians >	units::UNIT_ADD (angle, gigaradian, gigaradians, Grad, giga< radians >) UNIT_ADD(angle
template<>
constexpr const char *	units::name (const angle::degree_t &)
template<>
constexpr const char *	units::abbreviation (const angle::degree_t &)
template<>
constexpr const char *	units::name_plural (const angle::degree_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const degree_t &obj)
std::string	units::angle::to_string (const degree_t &obj)
template<>
constexpr const char *	units::name (const angle::arcminute_t &)
template<>
constexpr const char *	units::abbreviation (const angle::arcminute_t &)
template<>
constexpr const char *	units::name_plural (const angle::arcminute_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const arcminute_t &obj)
std::string	units::angle::to_string (const arcminute_t &obj)
template<>
constexpr const char *	units::name (const angle::arcsecond_t &)
template<>
constexpr const char *	units::abbreviation (const angle::arcsecond_t &)
template<>
constexpr const char *	units::name_plural (const angle::arcsecond_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const arcsecond_t &obj)
std::string	units::angle::to_string (const arcsecond_t &obj)
template<>
constexpr const char *	units::name (const angle::milliarcsecond_t &)
template<>
constexpr const char *	units::abbreviation (const angle::milliarcsecond_t &)
template<>
constexpr const char *	units::name_plural (const angle::milliarcsecond_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const milliarcsecond_t &obj)
std::string	units::angle::to_string (const milliarcsecond_t &obj)
template<>
constexpr const char *	units::name (const angle::turn_t &)
template<>
constexpr const char *	units::abbreviation (const angle::turn_t &)
template<>
constexpr const char *	units::name_plural (const angle::turn_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const turn_t &obj)
std::string	units::angle::to_string (const turn_t &obj)
template<>
constexpr const char *	units::name (const angle::gradian_t &)
template<>
constexpr const char *	units::abbreviation (const angle::gradian_t &)
template<>
constexpr const char *	units::name_plural (const angle::gradian_t &)
std::ostream &	units::angle::operator<< (std::ostream &os, const gradian_t &obj)
std::string	units::angle::to_string (const gradian_t &obj)
	units::UNIT_ADD_LITERALS (angle, gradian, gon) namespace traits
template<>
constexpr const char *	units::name (const current::ampere_t &)
template<>
constexpr const char *	units::abbreviation (const current::ampere_t &)
template<>
constexpr const char *	units::name_plural (const current::ampere_t &)
std::ostream &	units::current::operator<< (std::ostream &os, const ampere_t &obj)
std::string	units::current::to_string (const ampere_t &obj)
	units::UNIT_ADD_LITERALS (current, ampere, A) UNIT_ADD(current
femto< amperes >	units::UNIT_ADD (current, picoampere, picoamperes, pA, pico< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes >	units::UNIT_ADD (current, microampere, microamperes, uA, micro< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes >	units::UNIT_ADD (current, centiampere, centiamperes, cA, centi< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes >	units::UNIT_ADD (current, decaampere, decaamperes, daA, deca< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes >	units::UNIT_ADD (current, kiloampere, kiloamperes, kA, kilo< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes >	units::UNIT_ADD (current, gigaampere, gigaamperes, GA, giga< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes > tera< amperes >	units::UNIT_ADD (current, petaampere, petaamperes, PA, peta< amperes >) namespace traits
template<>
constexpr const char *	units::name (const temperature::kelvin_t &)
template<>
constexpr const char *	units::abbreviation (const temperature::kelvin_t &)
template<>
constexpr const char *	units::name_plural (const temperature::kelvin_t &)
std::ostream &	units::temperature::operator<< (std::ostream &os, const kelvin_t &obj)
std::string	units::temperature::to_string (const kelvin_t &obj)
template<>
constexpr const char *	units::name (const temperature::celsius_t &)
template<>
constexpr const char *	units::abbreviation (const temperature::celsius_t &)
template<>
constexpr const char *	units::name_plural (const temperature::celsius_t &)
std::ostream &	units::temperature::operator<< (std::ostream &os, const celsius_t &obj)
std::string	units::temperature::to_string (const celsius_t &obj)
template<>
constexpr const char *	units::name (const temperature::fahrenheit_t &)
template<>
constexpr const char *	units::abbreviation (const temperature::fahrenheit_t &)
template<>
constexpr const char *	units::name_plural (const temperature::fahrenheit_t &)
std::ostream &	units::temperature::operator<< (std::ostream &os, const fahrenheit_t &obj)
std::string	units::temperature::to_string (const fahrenheit_t &obj)
template<>
constexpr const char *	units::name (const temperature::reaumur_t &)
template<>
constexpr const char *	units::abbreviation (const temperature::reaumur_t &)
template<>
constexpr const char *	units::name_plural (const temperature::reaumur_t &)
std::ostream &	units::temperature::operator<< (std::ostream &os, const reaumur_t &obj)
std::string	units::temperature::to_string (const reaumur_t &obj)
template<>
constexpr const char *	units::name (const temperature::rankine_t &)
template<>
constexpr const char *	units::abbreviation (const temperature::rankine_t &)
template<>
constexpr const char *	units::name_plural (const temperature::rankine_t &)
std::ostream &	units::temperature::operator<< (std::ostream &os, const rankine_t &obj)
std::string	units::temperature::to_string (const rankine_t &obj)
	units::UNIT_ADD_LITERALS (temperature, rankine, Ra) namespace traits
template<>
constexpr const char *	units::name (const substance::mole_t &)
template<>
constexpr const char *	units::abbreviation (const substance::mole_t &)
template<>
constexpr const char *	units::name_plural (const substance::mole_t &)
std::ostream &	units::substance::operator<< (std::ostream &os, const mole_t &obj)
std::string	units::substance::to_string (const mole_t &obj)
	units::UNIT_ADD_LITERALS (substance, mole, mol) namespace traits
template<>
constexpr const char *	units::name (const luminous_intensity::candela_t &)
template<>
constexpr const char *	units::abbreviation (const luminous_intensity::candela_t &)
template<>
constexpr const char *	units::name_plural (const luminous_intensity::candela_t &)
std::ostream &	units::luminous_intensity::operator<< (std::ostream &os, const candela_t &obj)
std::string	units::luminous_intensity::to_string (const candela_t &obj)
	units::UNIT_ADD_LITERALS (luminous_intensity, candela, cd) UNIT_ADD(luminous_intensity
femto< candelas >	units::UNIT_ADD (luminous_intensity, picocandela, picocandelas, pcd, pico< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas >	units::UNIT_ADD (luminous_intensity, microcandela, microcandelas, ucd, micro< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas >	units::UNIT_ADD (luminous_intensity, centicandela, centicandelas, ccd, centi< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas >	units::UNIT_ADD (luminous_intensity, decacandela, decacandelas, dacd, deca< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas >	units::UNIT_ADD (luminous_intensity, kilocandela, kilocandelas, kcd, kilo< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas >	units::UNIT_ADD (luminous_intensity, gigacandela, gigacandelas, Gcd, giga< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas > tera< candelas >	units::UNIT_ADD (luminous_intensity, petacandela, petacandelas, Pcd, peta< candelas >) namespace traits
template<>
constexpr const char *	units::name (const solid_angle::steradian_t &)
template<>
constexpr const char *	units::abbreviation (const solid_angle::steradian_t &)
template<>
constexpr const char *	units::name_plural (const solid_angle::steradian_t &)
std::ostream &	units::solid_angle::operator<< (std::ostream &os, const steradian_t &obj)
std::string	units::solid_angle::to_string (const steradian_t &obj)
	units::UNIT_ADD_LITERALS (solid_angle, steradian, sr) UNIT_ADD(solid_angle
femto< steradians >	units::UNIT_ADD (solid_angle, picosteradian, picosteradians, psr, pico< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians >	units::UNIT_ADD (solid_angle, microsteradian, microsteradians, usr, micro< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians >	units::UNIT_ADD (solid_angle, centisteradian, centisteradians, csr, centi< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians > deci< steradians >	units::UNIT_ADD (solid_angle, decasteradian, decasteradians, dasr, deca< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians >	units::UNIT_ADD (solid_angle, kilosteradian, kilosteradians, ksr, kilo< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians > mega< steradians >	units::UNIT_ADD (solid_angle, gigasteradian, gigasteradians, Gsr, giga< steradians >) UNIT_ADD(solid_angle
template<>
constexpr const char *	units::name (const solid_angle::degree_squared_t &)
template<>
constexpr const char *	units::abbreviation (const solid_angle::degree_squared_t &)
template<>
constexpr const char *	units::name_plural (const solid_angle::degree_squared_t &)
std::ostream &	units::solid_angle::operator<< (std::ostream &os, const degree_squared_t &obj)
std::string	units::solid_angle::to_string (const degree_squared_t &obj)
template<>
constexpr const char *	units::name (const solid_angle::spat_t &)
template<>
constexpr const char *	units::abbreviation (const solid_angle::spat_t &)
template<>
constexpr const char *	units::name_plural (const solid_angle::spat_t &)
std::ostream &	units::solid_angle::operator<< (std::ostream &os, const spat_t &obj)
std::string	units::solid_angle::to_string (const spat_t &obj)
	units::UNIT_ADD_LITERALS (solid_angle, spat, sp) namespace traits
template<>
constexpr const char *	units::name (const frequency::hertz_t &)
template<>
constexpr const char *	units::abbreviation (const frequency::hertz_t &)
template<>
constexpr const char *	units::name_plural (const frequency::hertz_t &)
std::ostream &	units::frequency::operator<< (std::ostream &os, const hertz_t &obj)
std::string	units::frequency::to_string (const hertz_t &obj)
	units::UNIT_ADD_LITERALS (frequency, hertz, Hz) UNIT_ADD(frequency
femto< hertz >	units::UNIT_ADD (frequency, picohertz, picohertz, pHz, pico< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz >	units::UNIT_ADD (frequency, microhertz, microhertz, uHz, micro< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz >	units::UNIT_ADD (frequency, centihertz, centihertz, cHz, centi< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz >	units::UNIT_ADD (frequency, decahertz, decahertz, daHz, deca< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz >	units::UNIT_ADD (frequency, kilohertz, kilohertz, kHz, kilo< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz >	units::UNIT_ADD (frequency, gigahertz, gigahertz, GHz, giga< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz > tera< hertz >	units::UNIT_ADD (frequency, petahertz, petahertz, PHz, peta< hertz >) namespace traits
template<>
constexpr const char *	units::name (const velocity::meters_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const velocity::meters_per_second_t &)
template<>
constexpr const char *	units::name_plural (const velocity::meters_per_second_t &)
std::ostream &	units::velocity::operator<< (std::ostream &os, const meters_per_second_t &obj)
std::string	units::velocity::to_string (const meters_per_second_t &obj)
template<>
constexpr const char *	units::name (const velocity::feet_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const velocity::feet_per_second_t &)
template<>
constexpr const char *	units::name_plural (const velocity::feet_per_second_t &)
std::ostream &	units::velocity::operator<< (std::ostream &os, const feet_per_second_t &obj)
std::string	units::velocity::to_string (const feet_per_second_t &obj)
template<>
constexpr const char *	units::name (const velocity::miles_per_hour_t &)
template<>
constexpr const char *	units::abbreviation (const velocity::miles_per_hour_t &)
template<>
constexpr const char *	units::name_plural (const velocity::miles_per_hour_t &)
std::ostream &	units::velocity::operator<< (std::ostream &os, const miles_per_hour_t &obj)
std::string	units::velocity::to_string (const miles_per_hour_t &obj)
template<>
constexpr const char *	units::name (const velocity::kilometers_per_hour_t &)
template<>
constexpr const char *	units::abbreviation (const velocity::kilometers_per_hour_t &)
template<>
constexpr const char *	units::name_plural (const velocity::kilometers_per_hour_t &)
std::ostream &	units::velocity::operator<< (std::ostream &os, const kilometers_per_hour_t &obj)
std::string	units::velocity::to_string (const kilometers_per_hour_t &obj)
template<>
constexpr const char *	units::name (const velocity::knot_t &)
template<>
constexpr const char *	units::abbreviation (const velocity::knot_t &)
template<>
constexpr const char *	units::name_plural (const velocity::knot_t &)
std::ostream &	units::velocity::operator<< (std::ostream &os, const knot_t &obj)
std::string	units::velocity::to_string (const knot_t &obj)
	units::UNIT_ADD_LITERALS (velocity, knot, kts) namespace traits
template<>
constexpr const char *	units::name (const angular_velocity::radians_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const angular_velocity::radians_per_second_t &)
template<>
constexpr const char *	units::name_plural (const angular_velocity::radians_per_second_t &)
std::ostream &	units::angular_velocity::operator<< (std::ostream &os, const radians_per_second_t &obj)
std::string	units::angular_velocity::to_string (const radians_per_second_t &obj)
template<>
constexpr const char *	units::name (const angular_velocity::degrees_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const angular_velocity::degrees_per_second_t &)
template<>
constexpr const char *	units::name_plural (const angular_velocity::degrees_per_second_t &)
std::ostream &	units::angular_velocity::operator<< (std::ostream &os, const degrees_per_second_t &obj)
std::string	units::angular_velocity::to_string (const degrees_per_second_t &obj)
template<>
constexpr const char *	units::name (const angular_velocity::revolutions_per_minute_t &)
template<>
constexpr const char *	units::abbreviation (const angular_velocity::revolutions_per_minute_t &)
template<>
constexpr const char *	units::name_plural (const angular_velocity::revolutions_per_minute_t &)
std::ostream &	units::angular_velocity::operator<< (std::ostream &os, const revolutions_per_minute_t &obj)
std::string	units::angular_velocity::to_string (const revolutions_per_minute_t &obj)
template<>
constexpr const char *	units::name (const angular_velocity::revolutions_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const angular_velocity::revolutions_per_second_t &)
template<>
constexpr const char *	units::name_plural (const angular_velocity::revolutions_per_second_t &)
std::ostream &	units::angular_velocity::operator<< (std::ostream &os, const revolutions_per_second_t &obj)
std::string	units::angular_velocity::to_string (const revolutions_per_second_t &obj)
template<>
constexpr const char *	units::name (const angular_velocity::milliarcseconds_per_year_t &)
template<>
constexpr const char *	units::abbreviation (const angular_velocity::milliarcseconds_per_year_t &)
template<>
constexpr const char *	units::name_plural (const angular_velocity::milliarcseconds_per_year_t &)
std::ostream &	units::angular_velocity::operator<< (std::ostream &os, const milliarcseconds_per_year_t &obj)
std::string	units::angular_velocity::to_string (const milliarcseconds_per_year_t &obj)
	units::UNIT_ADD_LITERALS (angular_velocity, milliarcseconds_per_year, mas_per_yr) namespace traits
template<>
constexpr const char *	units::name (const acceleration::meters_per_second_squared_t &)
template<>
constexpr const char *	units::abbreviation (const acceleration::meters_per_second_squared_t &)
template<>
constexpr const char *	units::name_plural (const acceleration::meters_per_second_squared_t &)
std::ostream &	units::acceleration::operator<< (std::ostream &os, const meters_per_second_squared_t &obj)
std::string	units::acceleration::to_string (const meters_per_second_squared_t &obj)
template<>
constexpr const char *	units::name (const acceleration::feet_per_second_squared_t &)
template<>
constexpr const char *	units::abbreviation (const acceleration::feet_per_second_squared_t &)
template<>
constexpr const char *	units::name_plural (const acceleration::feet_per_second_squared_t &)
std::ostream &	units::acceleration::operator<< (std::ostream &os, const feet_per_second_squared_t &obj)
std::string	units::acceleration::to_string (const feet_per_second_squared_t &obj)
template<>
constexpr const char *	units::name (const acceleration::standard_gravity_t &)
template<>
constexpr const char *	units::abbreviation (const acceleration::standard_gravity_t &)
template<>
constexpr const char *	units::name_plural (const acceleration::standard_gravity_t &)
std::ostream &	units::acceleration::operator<< (std::ostream &os, const standard_gravity_t &obj)
std::string	units::acceleration::to_string (const standard_gravity_t &obj)
	units::UNIT_ADD_LITERALS (acceleration, standard_gravity, SG) namespace traits
template<>
constexpr const char *	units::name (const jerk::meters_per_second_cubed_t &)
template<>
constexpr const char *	units::abbreviation (const jerk::meters_per_second_cubed_t &)
template<>
constexpr const char *	units::name_plural (const jerk::meters_per_second_cubed_t &)
std::ostream &	units::jerk::operator<< (std::ostream &os, const meters_per_second_cubed_t &obj)
std::string	units::jerk::to_string (const meters_per_second_cubed_t &obj)
template<>
constexpr const char *	units::name (const jerk::feet_per_second_cubed_t &)
template<>
constexpr const char *	units::abbreviation (const jerk::feet_per_second_cubed_t &)
template<>
constexpr const char *	units::name_plural (const jerk::feet_per_second_cubed_t &)
std::ostream &	units::jerk::operator<< (std::ostream &os, const feet_per_second_cubed_t &obj)
std::string	units::jerk::to_string (const feet_per_second_cubed_t &obj)
	units::UNIT_ADD_LITERALS (jerk, feet_per_second_cubed, fps_cb) namespace traits
template<>
constexpr const char *	units::name (const force::newton_t &)
template<>
constexpr const char *	units::abbreviation (const force::newton_t &)
template<>
constexpr const char *	units::name_plural (const force::newton_t &)
std::ostream &	units::force::operator<< (std::ostream &os, const newton_t &obj)
std::string	units::force::to_string (const newton_t &obj)
	units::UNIT_ADD_LITERALS (force, newton, N) UNIT_ADD(force
femto< newtons >	units::UNIT_ADD (force, piconewton, piconewtons, pN, pico< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons >	units::UNIT_ADD (force, micronewton, micronewtons, uN, micro< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons >	units::UNIT_ADD (force, centinewton, centinewtons, cN, centi< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons >	units::UNIT_ADD (force, decanewton, decanewtons, daN, deca< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons >	units::UNIT_ADD (force, kilonewton, kilonewtons, kN, kilo< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons > mega< newtons >	units::UNIT_ADD (force, giganewton, giganewtons, GN, giga< newtons >) UNIT_ADD(force
template<>
constexpr const char *	units::name (const force::pound_t &)
template<>
constexpr const char *	units::abbreviation (const force::pound_t &)
template<>
constexpr const char *	units::name_plural (const force::pound_t &)
std::ostream &	units::force::operator<< (std::ostream &os, const pound_t &obj)
std::string	units::force::to_string (const pound_t &obj)
template<>
constexpr const char *	units::name (const force::dyne_t &)
template<>
constexpr const char *	units::abbreviation (const force::dyne_t &)
template<>
constexpr const char *	units::name_plural (const force::dyne_t &)
std::ostream &	units::force::operator<< (std::ostream &os, const dyne_t &obj)
std::string	units::force::to_string (const dyne_t &obj)
template<>
constexpr const char *	units::name (const force::kilopond_t &)
template<>
constexpr const char *	units::abbreviation (const force::kilopond_t &)
template<>
constexpr const char *	units::name_plural (const force::kilopond_t &)
std::ostream &	units::force::operator<< (std::ostream &os, const kilopond_t &obj)
std::string	units::force::to_string (const kilopond_t &obj)
template<>
constexpr const char *	units::name (const force::poundal_t &)
template<>
constexpr const char *	units::abbreviation (const force::poundal_t &)
template<>
constexpr const char *	units::name_plural (const force::poundal_t &)
std::ostream &	units::force::operator<< (std::ostream &os, const poundal_t &obj)
std::string	units::force::to_string (const poundal_t &obj)
	units::UNIT_ADD_LITERALS (force, poundal, pdl) namespace traits
template<>
constexpr const char *	units::name (const pressure::pascal_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::pascal_t &)
template<>
constexpr const char *	units::name_plural (const pressure::pascal_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const pascal_t &obj)
std::string	units::pressure::to_string (const pascal_t &obj)
	units::UNIT_ADD_LITERALS (pressure, pascal, Pa) UNIT_ADD(pressure
femto< pascals >	units::UNIT_ADD (pressure, picopascal, picopascals, pPa, pico< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals >	units::UNIT_ADD (pressure, micropascal, micropascals, uPa, micro< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals >	units::UNIT_ADD (pressure, centipascal, centipascals, cPa, centi< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals >	units::UNIT_ADD (pressure, decapascal, decapascals, daPa, deca< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals >	units::UNIT_ADD (pressure, kilopascal, kilopascals, kPa, kilo< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals > mega< pascals >	units::UNIT_ADD (pressure, gigapascal, gigapascals, GPa, giga< pascals >) UNIT_ADD(pressure
template<>
constexpr const char *	units::name (const pressure::bar_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::bar_t &)
template<>
constexpr const char *	units::name_plural (const pressure::bar_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const bar_t &obj)
std::string	units::pressure::to_string (const bar_t &obj)
template<>
constexpr const char *	units::name (const pressure::mbar_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::mbar_t &)
template<>
constexpr const char *	units::name_plural (const pressure::mbar_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const mbar_t &obj)
std::string	units::pressure::to_string (const mbar_t &obj)
template<>
constexpr const char *	units::name (const pressure::atmosphere_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::atmosphere_t &)
template<>
constexpr const char *	units::name_plural (const pressure::atmosphere_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const atmosphere_t &obj)
std::string	units::pressure::to_string (const atmosphere_t &obj)
template<>
constexpr const char *	units::name (const pressure::pounds_per_square_inch_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::pounds_per_square_inch_t &)
template<>
constexpr const char *	units::name_plural (const pressure::pounds_per_square_inch_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const pounds_per_square_inch_t &obj)
std::string	units::pressure::to_string (const pounds_per_square_inch_t &obj)
template<>
constexpr const char *	units::name (const pressure::torr_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::torr_t &)
template<>
constexpr const char *	units::name_plural (const pressure::torr_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const torr_t &obj)
std::string	units::pressure::to_string (const torr_t &obj)
template<>
constexpr const char *	units::name (const pressure::millimeter_of_mercury_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::millimeter_of_mercury_t &)
template<>
constexpr const char *	units::name_plural (const pressure::millimeter_of_mercury_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const millimeter_of_mercury_t &obj)
std::string	units::pressure::to_string (const millimeter_of_mercury_t &obj)
template<>
constexpr const char *	units::name (const pressure::inch_of_mercury_t &)
template<>
constexpr const char *	units::abbreviation (const pressure::inch_of_mercury_t &)
template<>
constexpr const char *	units::name_plural (const pressure::inch_of_mercury_t &)
std::ostream &	units::pressure::operator<< (std::ostream &os, const inch_of_mercury_t &obj)
std::string	units::pressure::to_string (const inch_of_mercury_t &obj)
	units::UNIT_ADD_LITERALS (pressure, inch_of_mercury, inHg) namespace traits
template<>
constexpr const char *	units::name (const charge::coulomb_t &)
template<>
constexpr const char *	units::abbreviation (const charge::coulomb_t &)
template<>
constexpr const char *	units::name_plural (const charge::coulomb_t &)
std::ostream &	units::charge::operator<< (std::ostream &os, const coulomb_t &obj)
std::string	units::charge::to_string (const coulomb_t &obj)
	units::UNIT_ADD_LITERALS (charge, coulomb, C) UNIT_ADD(charge
femto< coulombs >	units::UNIT_ADD (charge, picocoulomb, picocoulombs, pC, pico< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs >	units::UNIT_ADD (charge, microcoulomb, microcoulombs, uC, micro< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs >	units::UNIT_ADD (charge, centicoulomb, centicoulombs, cC, centi< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs >	units::UNIT_ADD (charge, decacoulomb, decacoulombs, daC, deca< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs >	units::UNIT_ADD (charge, kilocoulomb, kilocoulombs, kC, kilo< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs > mega< coulombs >	units::UNIT_ADD (charge, gigacoulomb, gigacoulombs, GC, giga< coulombs >) UNIT_ADD(charge
template<>
constexpr const char *	units::name (const charge::ampere_hour_t &)
template<>
constexpr const char *	units::abbreviation (const charge::ampere_hour_t &)
template<>
constexpr const char *	units::name_plural (const charge::ampere_hour_t &)
std::ostream &	units::charge::operator<< (std::ostream &os, const ampere_hour_t &obj)
std::string	units::charge::to_string (const ampere_hour_t &obj)
	units::UNIT_ADD_LITERALS (charge, ampere_hour, Ah) UNIT_ADD(charge
femto< ampere_hours >	units::UNIT_ADD (charge, picoampere_hour, picoampere_hours, pAh, pico< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours >	units::UNIT_ADD (charge, microampere_hour, microampere_hours, uAh, micro< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours >	units::UNIT_ADD (charge, centiampere_hour, centiampere_hours, cAh, centi< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours >	units::UNIT_ADD (charge, decaampere_hour, decaampere_hours, daAh, deca< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours >	units::UNIT_ADD (charge, kiloampere_hour, kiloampere_hours, kAh, kilo< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours > mega< ampere_hours >	units::UNIT_ADD (charge, gigaampere_hour, gigaampere_hours, GAh, giga< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours > mega< ampere_hours > tera< ampere_hours >	units::UNIT_ADD (charge, petaampere_hour, petaampere_hours, PAh, peta< ampere_hours >) namespace traits
template<>
constexpr const char *	units::name (const energy::joule_t &)
template<>
constexpr const char *	units::abbreviation (const energy::joule_t &)
template<>
constexpr const char *	units::name_plural (const energy::joule_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const joule_t &obj)
std::string	units::energy::to_string (const joule_t &obj)
	units::UNIT_ADD_LITERALS (energy, joule, J) UNIT_ADD(energy
femto< joules >	units::UNIT_ADD (energy, picojoule, picojoules, pJ, pico< joules >) UNIT_ADD(energy
femto< joules > nano< joules >	units::UNIT_ADD (energy, microjoule, microjoules, uJ, micro< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules >	units::UNIT_ADD (energy, centijoule, centijoules, cJ, centi< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules >	units::UNIT_ADD (energy, decajoule, decajoules, daJ, deca< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules >	units::UNIT_ADD (energy, kilojoule, kilojoules, kJ, kilo< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules > mega< joules >	units::UNIT_ADD (energy, gigajoule, gigajoules, GJ, giga< joules >) UNIT_ADD(energy
template<>
constexpr const char *	units::name (const energy::calorie_t &)
template<>
constexpr const char *	units::abbreviation (const energy::calorie_t &)
template<>
constexpr const char *	units::name_plural (const energy::calorie_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const calorie_t &obj)
std::string	units::energy::to_string (const calorie_t &obj)
	units::UNIT_ADD_LITERALS (energy, calorie, cal) UNIT_ADD(energy
femto< calories >	units::UNIT_ADD (energy, picocalorie, picocalories, pcal, pico< calories >) UNIT_ADD(energy
femto< calories > nano< calories >	units::UNIT_ADD (energy, microcalorie, microcalories, ucal, micro< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories >	units::UNIT_ADD (energy, centicalorie, centicalories, ccal, centi< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories >	units::UNIT_ADD (energy, decacalorie, decacalories, dacal, deca< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories >	units::UNIT_ADD (energy, kilocalorie, kilocalories, kcal, kilo< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories > mega< calories >	units::UNIT_ADD (energy, gigacalorie, gigacalories, Gcal, giga< calories >) UNIT_ADD(energy
template<>
constexpr const char *	units::name (const energy::kilowatt_hour_t &)
template<>
constexpr const char *	units::abbreviation (const energy::kilowatt_hour_t &)
template<>
constexpr const char *	units::name_plural (const energy::kilowatt_hour_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const kilowatt_hour_t &obj)
std::string	units::energy::to_string (const kilowatt_hour_t &obj)
template<>
constexpr const char *	units::name (const energy::watt_hour_t &)
template<>
constexpr const char *	units::abbreviation (const energy::watt_hour_t &)
template<>
constexpr const char *	units::name_plural (const energy::watt_hour_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const watt_hour_t &obj)
std::string	units::energy::to_string (const watt_hour_t &obj)
template<>
constexpr const char *	units::name (const energy::british_thermal_unit_t &)
template<>
constexpr const char *	units::abbreviation (const energy::british_thermal_unit_t &)
template<>
constexpr const char *	units::name_plural (const energy::british_thermal_unit_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const british_thermal_unit_t &obj)
std::string	units::energy::to_string (const british_thermal_unit_t &obj)
template<>
constexpr const char *	units::name (const energy::british_thermal_unit_iso_t &)
template<>
constexpr const char *	units::abbreviation (const energy::british_thermal_unit_iso_t &)
template<>
constexpr const char *	units::name_plural (const energy::british_thermal_unit_iso_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const british_thermal_unit_iso_t &obj)
std::string	units::energy::to_string (const british_thermal_unit_iso_t &obj)
template<>
constexpr const char *	units::name (const energy::british_thermal_unit_59_t &)
template<>
constexpr const char *	units::abbreviation (const energy::british_thermal_unit_59_t &)
template<>
constexpr const char *	units::name_plural (const energy::british_thermal_unit_59_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const british_thermal_unit_59_t &obj)
std::string	units::energy::to_string (const british_thermal_unit_59_t &obj)
template<>
constexpr const char *	units::name (const energy::therm_t &)
template<>
constexpr const char *	units::abbreviation (const energy::therm_t &)
template<>
constexpr const char *	units::name_plural (const energy::therm_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const therm_t &obj)
std::string	units::energy::to_string (const therm_t &obj)
template<>
constexpr const char *	units::name (const energy::foot_pound_t &)
template<>
constexpr const char *	units::abbreviation (const energy::foot_pound_t &)
template<>
constexpr const char *	units::name_plural (const energy::foot_pound_t &)
std::ostream &	units::energy::operator<< (std::ostream &os, const foot_pound_t &obj)
std::string	units::energy::to_string (const foot_pound_t &obj)
	units::UNIT_ADD_LITERALS (energy, foot_pound, ftlbf) namespace traits
template<>
constexpr const char *	units::name (const power::watt_t &)
template<>
constexpr const char *	units::abbreviation (const power::watt_t &)
template<>
constexpr const char *	units::name_plural (const power::watt_t &)
std::ostream &	units::power::operator<< (std::ostream &os, const watt_t &obj)
std::string	units::power::to_string (const watt_t &obj)
	units::UNIT_ADD_LITERALS (power, watt, W) UNIT_ADD(power
femto< watts >	units::UNIT_ADD (power, picowatt, picowatts, pW, pico< watts >) UNIT_ADD(power
femto< watts > nano< watts >	units::UNIT_ADD (power, microwatt, microwatts, uW, micro< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts >	units::UNIT_ADD (power, centiwatt, centiwatts, cW, centi< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts >	units::UNIT_ADD (power, decawatt, decawatts, daW, deca< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts >	units::UNIT_ADD (power, kilowatt, kilowatts, kW, kilo< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts > mega< watts >	units::UNIT_ADD (power, gigawatt, gigawatts, GW, giga< watts >) UNIT_ADD(power
template<>
constexpr const char *	units::name (const power::horsepower_t &)
template<>
constexpr const char *	units::abbreviation (const power::horsepower_t &)
template<>
constexpr const char *	units::name_plural (const power::horsepower_t &)
std::ostream &	units::power::operator<< (std::ostream &os, const horsepower_t &obj)
std::string	units::power::to_string (const horsepower_t &obj)
std::ostream &	units::power::operator<< (std::ostream &os, const dBW_t &obj)
std::string	units::power::to_string (const dBW_t &obj)
std::ostream &	units::power::operator<< (std::ostream &os, const dBm_t &obj)
std::string	units::power::to_string (const dBm_t &obj)
	units::UNIT_ADD_LITERALS (power, dBm, dBm) namespace traits
template<>
constexpr const char *	units::name (const voltage::volt_t &)
template<>
constexpr const char *	units::abbreviation (const voltage::volt_t &)
template<>
constexpr const char *	units::name_plural (const voltage::volt_t &)
std::ostream &	units::voltage::operator<< (std::ostream &os, const volt_t &obj)
std::string	units::voltage::to_string (const volt_t &obj)
	units::UNIT_ADD_LITERALS (voltage, volt, V) UNIT_ADD(voltage
femto< volts >	units::UNIT_ADD (voltage, picovolt, picovolts, pV, pico< volts >) UNIT_ADD(voltage
femto< volts > nano< volts >	units::UNIT_ADD (voltage, microvolt, microvolts, uV, micro< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts >	units::UNIT_ADD (voltage, centivolt, centivolts, cV, centi< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts >	units::UNIT_ADD (voltage, decavolt, decavolts, daV, deca< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts >	units::UNIT_ADD (voltage, kilovolt, kilovolts, kV, kilo< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts > mega< volts >	units::UNIT_ADD (voltage, gigavolt, gigavolts, GV, giga< volts >) UNIT_ADD(voltage
template<>
constexpr const char *	units::name (const voltage::statvolt_t &)
template<>
constexpr const char *	units::abbreviation (const voltage::statvolt_t &)
template<>
constexpr const char *	units::name_plural (const voltage::statvolt_t &)
std::ostream &	units::voltage::operator<< (std::ostream &os, const statvolt_t &obj)
std::string	units::voltage::to_string (const statvolt_t &obj)
template<>
constexpr const char *	units::name (const voltage::abvolt_t &)
template<>
constexpr const char *	units::abbreviation (const voltage::abvolt_t &)
template<>
constexpr const char *	units::name_plural (const voltage::abvolt_t &)
std::ostream &	units::voltage::operator<< (std::ostream &os, const abvolt_t &obj)
std::string	units::voltage::to_string (const abvolt_t &obj)
	units::UNIT_ADD_LITERALS (voltage, abvolt, abV) namespace traits
template<>
constexpr const char *	units::name (const capacitance::farad_t &)
template<>
constexpr const char *	units::abbreviation (const capacitance::farad_t &)
template<>
constexpr const char *	units::name_plural (const capacitance::farad_t &)
std::ostream &	units::capacitance::operator<< (std::ostream &os, const farad_t &obj)
std::string	units::capacitance::to_string (const farad_t &obj)
	units::UNIT_ADD_LITERALS (capacitance, farad, F) UNIT_ADD(capacitance
femto< farads >	units::UNIT_ADD (capacitance, picofarad, picofarads, pF, pico< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads >	units::UNIT_ADD (capacitance, microfarad, microfarads, uF, micro< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads >	units::UNIT_ADD (capacitance, centifarad, centifarads, cF, centi< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads >	units::UNIT_ADD (capacitance, decafarad, decafarads, daF, deca< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads >	units::UNIT_ADD (capacitance, kilofarad, kilofarads, kF, kilo< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads >	units::UNIT_ADD (capacitance, gigafarad, gigafarads, GF, giga< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads > tera< farads >	units::UNIT_ADD (capacitance, petafarad, petafarads, PF, peta< farads >) namespace traits
template<>
constexpr const char *	units::name (const impedance::ohm_t &)
template<>
constexpr const char *	units::abbreviation (const impedance::ohm_t &)
template<>
constexpr const char *	units::name_plural (const impedance::ohm_t &)
std::ostream &	units::impedance::operator<< (std::ostream &os, const ohm_t &obj)
std::string	units::impedance::to_string (const ohm_t &obj)
	units::UNIT_ADD_LITERALS (impedance, ohm, Ohm) UNIT_ADD(impedance
femto< ohms >	units::UNIT_ADD (impedance, picoohm, picoohms, pOhm, pico< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms >	units::UNIT_ADD (impedance, microohm, microohms, uOhm, micro< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms >	units::UNIT_ADD (impedance, centiohm, centiohms, cOhm, centi< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms >	units::UNIT_ADD (impedance, decaohm, decaohms, daOhm, deca< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms >	units::UNIT_ADD (impedance, kiloohm, kiloohms, kOhm, kilo< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms >	units::UNIT_ADD (impedance, gigaohm, gigaohms, GOhm, giga< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms > tera< ohms >	units::UNIT_ADD (impedance, petaohm, petaohms, POhm, peta< ohms >) namespace traits
template<>
constexpr const char *	units::name (const conductance::siemens_t &)
template<>
constexpr const char *	units::abbreviation (const conductance::siemens_t &)
template<>
constexpr const char *	units::name_plural (const conductance::siemens_t &)
std::ostream &	units::conductance::operator<< (std::ostream &os, const siemens_t &obj)
std::string	units::conductance::to_string (const siemens_t &obj)
	units::UNIT_ADD_LITERALS (conductance, siemens, S) UNIT_ADD(conductance
femto< siemens >	units::UNIT_ADD (conductance, picosiemens, picosiemens, pS, pico< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens >	units::UNIT_ADD (conductance, microsiemens, microsiemens, uS, micro< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens >	units::UNIT_ADD (conductance, centisiemens, centisiemens, cS, centi< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens >	units::UNIT_ADD (conductance, decasiemens, decasiemens, daS, deca< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens >	units::UNIT_ADD (conductance, kilosiemens, kilosiemens, kS, kilo< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens >	units::UNIT_ADD (conductance, gigasiemens, gigasiemens, GS, giga< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens > tera< siemens >	units::UNIT_ADD (conductance, petasiemens, petasiemens, PS, peta< siemens >) namespace traits
template<>
constexpr const char *	units::name (const magnetic_flux::weber_t &)
template<>
constexpr const char *	units::abbreviation (const magnetic_flux::weber_t &)
template<>
constexpr const char *	units::name_plural (const magnetic_flux::weber_t &)
std::ostream &	units::magnetic_flux::operator<< (std::ostream &os, const weber_t &obj)
std::string	units::magnetic_flux::to_string (const weber_t &obj)
	units::UNIT_ADD_LITERALS (magnetic_flux, weber, Wb) UNIT_ADD(magnetic_flux
femto< webers >	units::UNIT_ADD (magnetic_flux, picoweber, picowebers, pWb, pico< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers >	units::UNIT_ADD (magnetic_flux, microweber, microwebers, uWb, micro< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers >	units::UNIT_ADD (magnetic_flux, centiweber, centiwebers, cWb, centi< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers > deci< webers >	units::UNIT_ADD (magnetic_flux, decaweber, decawebers, daWb, deca< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers >	units::UNIT_ADD (magnetic_flux, kiloweber, kilowebers, kWb, kilo< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers > mega< webers >	units::UNIT_ADD (magnetic_flux, gigaweber, gigawebers, GWb, giga< webers >) UNIT_ADD(magnetic_flux
template<>
constexpr const char *	units::name (const magnetic_flux::maxwell_t &)
template<>
constexpr const char *	units::abbreviation (const magnetic_flux::maxwell_t &)
template<>
constexpr const char *	units::name_plural (const magnetic_flux::maxwell_t &)
std::ostream &	units::magnetic_flux::operator<< (std::ostream &os, const maxwell_t &obj)
std::string	units::magnetic_flux::to_string (const maxwell_t &obj)
	units::UNIT_ADD_LITERALS (magnetic_flux, maxwell, Mx) namespace traits
template<>
constexpr const char *	units::name (const magnetic_field_strength::tesla_t &)
template<>
constexpr const char *	units::abbreviation (const magnetic_field_strength::tesla_t &)
template<>
constexpr const char *	units::name_plural (const magnetic_field_strength::tesla_t &)
std::ostream &	units::magnetic_field_strength::operator<< (std::ostream &os, const tesla_t &obj)
std::string	units::magnetic_field_strength::to_string (const tesla_t &obj)
	units::UNIT_ADD_LITERALS (magnetic_field_strength, tesla, Te) UNIT_ADD(magnetic_field_strength
femto< teslas >	units::UNIT_ADD (magnetic_field_strength, picotesla, picoteslas, pTe, pico< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas >	units::UNIT_ADD (magnetic_field_strength, microtesla, microteslas, uTe, micro< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas >	units::UNIT_ADD (magnetic_field_strength, centitesla, centiteslas, cTe, centi< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas > deci< teslas >	units::UNIT_ADD (magnetic_field_strength, decatesla, decateslas, daTe, deca< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas >	units::UNIT_ADD (magnetic_field_strength, kilotesla, kiloteslas, kTe, kilo< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas > mega< teslas >	units::UNIT_ADD (magnetic_field_strength, gigatesla, gigateslas, GTe, giga< teslas >) UNIT_ADD(magnetic_field_strength
template<>
constexpr const char *	units::name (const magnetic_field_strength::gauss_t &)
template<>
constexpr const char *	units::abbreviation (const magnetic_field_strength::gauss_t &)
template<>
constexpr const char *	units::name_plural (const magnetic_field_strength::gauss_t &)
std::ostream &	units::magnetic_field_strength::operator<< (std::ostream &os, const gauss_t &obj)
std::string	units::magnetic_field_strength::to_string (const gauss_t &obj)
	units::UNIT_ADD_LITERALS (magnetic_field_strength, gauss, G) namespace traits
template<>
constexpr const char *	units::name (const inductance::henry_t &)
template<>
constexpr const char *	units::abbreviation (const inductance::henry_t &)
template<>
constexpr const char *	units::name_plural (const inductance::henry_t &)
std::ostream &	units::inductance::operator<< (std::ostream &os, const henry_t &obj)
std::string	units::inductance::to_string (const henry_t &obj)
	units::UNIT_ADD_LITERALS (inductance, henry, H) UNIT_ADD(inductance
femto< henries >	units::UNIT_ADD (inductance, picohenry, picohenries, pH, pico< henries >) UNIT_ADD(inductance
femto< henries > nano< henries >	units::UNIT_ADD (inductance, microhenry, microhenries, uH, micro< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries >	units::UNIT_ADD (inductance, centihenry, centihenries, cH, centi< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries >	units::UNIT_ADD (inductance, decahenry, decahenries, daH, deca< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries >	units::UNIT_ADD (inductance, kilohenry, kilohenries, kH, kilo< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries >	units::UNIT_ADD (inductance, gigahenry, gigahenries, GH, giga< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries > tera< henries >	units::UNIT_ADD (inductance, petahenry, petahenries, PH, peta< henries >) namespace traits
template<>
constexpr const char *	units::name (const luminous_flux::lumen_t &)
template<>
constexpr const char *	units::abbreviation (const luminous_flux::lumen_t &)
template<>
constexpr const char *	units::name_plural (const luminous_flux::lumen_t &)
std::ostream &	units::luminous_flux::operator<< (std::ostream &os, const lumen_t &obj)
std::string	units::luminous_flux::to_string (const lumen_t &obj)
	units::UNIT_ADD_LITERALS (luminous_flux, lumen, lm) UNIT_ADD(luminous_flux
femto< lumens >	units::UNIT_ADD (luminous_flux, picolumen, picolumens, plm, pico< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens >	units::UNIT_ADD (luminous_flux, microlumen, microlumens, ulm, micro< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens >	units::UNIT_ADD (luminous_flux, centilumen, centilumens, clm, centi< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens >	units::UNIT_ADD (luminous_flux, decalumen, decalumens, dalm, deca< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens >	units::UNIT_ADD (luminous_flux, kilolumen, kilolumens, klm, kilo< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens >	units::UNIT_ADD (luminous_flux, gigalumen, gigalumens, Glm, giga< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens > tera< lumens >	units::UNIT_ADD (luminous_flux, petalumen, petalumens, Plm, peta< lumens >) namespace traits
template<>
constexpr const char *	units::name (const illuminance::lux_t &)
template<>
constexpr const char *	units::abbreviation (const illuminance::lux_t &)
template<>
constexpr const char *	units::name_plural (const illuminance::lux_t &)
std::ostream &	units::illuminance::operator<< (std::ostream &os, const lux_t &obj)
std::string	units::illuminance::to_string (const lux_t &obj)
	units::UNIT_ADD_LITERALS (illuminance, lux, lx) UNIT_ADD(illuminance
femto< luxes >	units::UNIT_ADD (illuminance, picolux, picoluxes, plx, pico< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes >	units::UNIT_ADD (illuminance, microlux, microluxes, ulx, micro< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes >	units::UNIT_ADD (illuminance, centilux, centiluxes, clx, centi< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes >	units::UNIT_ADD (illuminance, decalux, decaluxes, dalx, deca< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes >	units::UNIT_ADD (illuminance, kilolux, kiloluxes, klx, kilo< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes > mega< luxes >	units::UNIT_ADD (illuminance, gigalux, gigaluxes, Glx, giga< luxes >) UNIT_ADD(illuminance
template<>
constexpr const char *	units::name (const illuminance::footcandle_t &)
template<>
constexpr const char *	units::abbreviation (const illuminance::footcandle_t &)
template<>
constexpr const char *	units::name_plural (const illuminance::footcandle_t &)
std::ostream &	units::illuminance::operator<< (std::ostream &os, const footcandle_t &obj)
std::string	units::illuminance::to_string (const footcandle_t &obj)
template<>
constexpr const char *	units::name (const illuminance::lumens_per_square_inch_t &)
template<>
constexpr const char *	units::abbreviation (const illuminance::lumens_per_square_inch_t &)
template<>
constexpr const char *	units::name_plural (const illuminance::lumens_per_square_inch_t &)
std::ostream &	units::illuminance::operator<< (std::ostream &os, const lumens_per_square_inch_t &obj)
std::string	units::illuminance::to_string (const lumens_per_square_inch_t &obj)
template<>
constexpr const char *	units::name (const illuminance::phot_t &)
template<>
constexpr const char *	units::abbreviation (const illuminance::phot_t &)
template<>
constexpr const char *	units::name_plural (const illuminance::phot_t &)
std::ostream &	units::illuminance::operator<< (std::ostream &os, const phot_t &obj)
std::string	units::illuminance::to_string (const phot_t &obj)
	units::UNIT_ADD_LITERALS (illuminance, phot, ph) namespace traits
template<>
constexpr const char *	units::name (const radiation::becquerel_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::becquerel_t &)
template<>
constexpr const char *	units::name_plural (const radiation::becquerel_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const becquerel_t &obj)
std::string	units::radiation::to_string (const becquerel_t &obj)
	units::UNIT_ADD_LITERALS (radiation, becquerel, Bq) UNIT_ADD(radiation
femto< becquerels >	units::UNIT_ADD (radiation, picobecquerel, picobecquerels, pBq, pico< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels >	units::UNIT_ADD (radiation, microbecquerel, microbecquerels, uBq, micro< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels >	units::UNIT_ADD (radiation, centibecquerel, centibecquerels, cBq, centi< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels >	units::UNIT_ADD (radiation, decabecquerel, decabecquerels, daBq, deca< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels >	units::UNIT_ADD (radiation, kilobecquerel, kilobecquerels, kBq, kilo< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels > mega< becquerels >	units::UNIT_ADD (radiation, gigabecquerel, gigabecquerels, GBq, giga< becquerels >) UNIT_ADD(radiation
template<>
constexpr const char *	units::name (const radiation::gray_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::gray_t &)
template<>
constexpr const char *	units::name_plural (const radiation::gray_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const gray_t &obj)
std::string	units::radiation::to_string (const gray_t &obj)
	units::UNIT_ADD_LITERALS (radiation, gray, Gy) UNIT_ADD(radiation
femto< grays >	units::UNIT_ADD (radiation, picogray, picograys, pGy, pico< grays >) UNIT_ADD(radiation
femto< grays > nano< grays >	units::UNIT_ADD (radiation, microgray, micrograys, uGy, micro< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays >	units::UNIT_ADD (radiation, centigray, centigrays, cGy, centi< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays >	units::UNIT_ADD (radiation, decagray, decagrays, daGy, deca< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays >	units::UNIT_ADD (radiation, kilogray, kilograys, kGy, kilo< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays > mega< grays >	units::UNIT_ADD (radiation, gigagray, gigagrays, GGy, giga< grays >) UNIT_ADD(radiation
template<>
constexpr const char *	units::name (const radiation::sievert_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::sievert_t &)
template<>
constexpr const char *	units::name_plural (const radiation::sievert_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const sievert_t &obj)
std::string	units::radiation::to_string (const sievert_t &obj)
	units::UNIT_ADD_LITERALS (radiation, sievert, Sv) UNIT_ADD(radiation
femto< sieverts >	units::UNIT_ADD (radiation, picosievert, picosieverts, pSv, pico< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts >	units::UNIT_ADD (radiation, microsievert, microsieverts, uSv, micro< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts >	units::UNIT_ADD (radiation, centisievert, centisieverts, cSv, centi< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts >	units::UNIT_ADD (radiation, decasievert, decasieverts, daSv, deca< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts >	units::UNIT_ADD (radiation, kilosievert, kilosieverts, kSv, kilo< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts > mega< sieverts >	units::UNIT_ADD (radiation, gigasievert, gigasieverts, GSv, giga< sieverts >) UNIT_ADD(radiation
template<>
constexpr const char *	units::name (const radiation::curie_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::curie_t &)
template<>
constexpr const char *	units::name_plural (const radiation::curie_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const curie_t &obj)
std::string	units::radiation::to_string (const curie_t &obj)
template<>
constexpr const char *	units::name (const radiation::rutherford_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::rutherford_t &)
template<>
constexpr const char *	units::name_plural (const radiation::rutherford_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const rutherford_t &obj)
std::string	units::radiation::to_string (const rutherford_t &obj)
template<>
constexpr const char *	units::name (const radiation::rad_t &)
template<>
constexpr const char *	units::abbreviation (const radiation::rad_t &)
template<>
constexpr const char *	units::name_plural (const radiation::rad_t &)
std::ostream &	units::radiation::operator<< (std::ostream &os, const rad_t &obj)
std::string	units::radiation::to_string (const rad_t &obj)
	units::UNIT_ADD_LITERALS (radiation, rad, rads) namespace traits
template<>
constexpr const char *	units::name (const torque::newton_meter_t &)
template<>
constexpr const char *	units::abbreviation (const torque::newton_meter_t &)
template<>
constexpr const char *	units::name_plural (const torque::newton_meter_t &)
std::ostream &	units::torque::operator<< (std::ostream &os, const newton_meter_t &obj)
std::string	units::torque::to_string (const newton_meter_t &obj)
template<>
constexpr const char *	units::name (const torque::foot_pound_t &)
template<>
constexpr const char *	units::abbreviation (const torque::foot_pound_t &)
template<>
constexpr const char *	units::name_plural (const torque::foot_pound_t &)
std::ostream &	units::torque::operator<< (std::ostream &os, const foot_pound_t &obj)
std::string	units::torque::to_string (const foot_pound_t &obj)
template<>
constexpr const char *	units::name (const torque::foot_poundal_t &)
template<>
constexpr const char *	units::abbreviation (const torque::foot_poundal_t &)
template<>
constexpr const char *	units::name_plural (const torque::foot_poundal_t &)
std::ostream &	units::torque::operator<< (std::ostream &os, const foot_poundal_t &obj)
std::string	units::torque::to_string (const foot_poundal_t &obj)
template<>
constexpr const char *	units::name (const torque::inch_pound_t &)
template<>
constexpr const char *	units::abbreviation (const torque::inch_pound_t &)
template<>
constexpr const char *	units::name_plural (const torque::inch_pound_t &)
std::ostream &	units::torque::operator<< (std::ostream &os, const inch_pound_t &obj)
std::string	units::torque::to_string (const inch_pound_t &obj)
template<>
constexpr const char *	units::name (const torque::meter_kilogram_t &)
template<>
constexpr const char *	units::abbreviation (const torque::meter_kilogram_t &)
template<>
constexpr const char *	units::name_plural (const torque::meter_kilogram_t &)
std::ostream &	units::torque::operator<< (std::ostream &os, const meter_kilogram_t &obj)
std::string	units::torque::to_string (const meter_kilogram_t &obj)
	units::UNIT_ADD_LITERALS (torque, meter_kilogram, mkgf) namespace traits
template<>
constexpr const char *	units::name (const area::square_meter_t &)
template<>
constexpr const char *	units::abbreviation (const area::square_meter_t &)
template<>
constexpr const char *	units::name_plural (const area::square_meter_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const square_meter_t &obj)
std::string	units::area::to_string (const square_meter_t &obj)
template<>
constexpr const char *	units::name (const area::square_foot_t &)
template<>
constexpr const char *	units::abbreviation (const area::square_foot_t &)
template<>
constexpr const char *	units::name_plural (const area::square_foot_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const square_foot_t &obj)
std::string	units::area::to_string (const square_foot_t &obj)
template<>
constexpr const char *	units::name (const area::square_inch_t &)
template<>
constexpr const char *	units::abbreviation (const area::square_inch_t &)
template<>
constexpr const char *	units::name_plural (const area::square_inch_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const square_inch_t &obj)
std::string	units::area::to_string (const square_inch_t &obj)
template<>
constexpr const char *	units::name (const area::square_mile_t &)
template<>
constexpr const char *	units::abbreviation (const area::square_mile_t &)
template<>
constexpr const char *	units::name_plural (const area::square_mile_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const square_mile_t &obj)
std::string	units::area::to_string (const square_mile_t &obj)
template<>
constexpr const char *	units::name (const area::square_kilometer_t &)
template<>
constexpr const char *	units::abbreviation (const area::square_kilometer_t &)
template<>
constexpr const char *	units::name_plural (const area::square_kilometer_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const square_kilometer_t &obj)
std::string	units::area::to_string (const square_kilometer_t &obj)
template<>
constexpr const char *	units::name (const area::hectare_t &)
template<>
constexpr const char *	units::abbreviation (const area::hectare_t &)
template<>
constexpr const char *	units::name_plural (const area::hectare_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const hectare_t &obj)
std::string	units::area::to_string (const hectare_t &obj)
template<>
constexpr const char *	units::name (const area::acre_t &)
template<>
constexpr const char *	units::abbreviation (const area::acre_t &)
template<>
constexpr const char *	units::name_plural (const area::acre_t &)
std::ostream &	units::area::operator<< (std::ostream &os, const acre_t &obj)
std::string	units::area::to_string (const acre_t &obj)
	units::UNIT_ADD_LITERALS (area, acre, acre) namespace traits
template<>
constexpr const char *	units::name (const volume::cubic_meter_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_meter_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_meter_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_meter_t &obj)
std::string	units::volume::to_string (const cubic_meter_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_millimeter_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_millimeter_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_millimeter_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_millimeter_t &obj)
std::string	units::volume::to_string (const cubic_millimeter_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_kilometer_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_kilometer_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_kilometer_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_kilometer_t &obj)
std::string	units::volume::to_string (const cubic_kilometer_t &obj)
template<>
constexpr const char *	units::name (const volume::liter_t &)
template<>
constexpr const char *	units::abbreviation (const volume::liter_t &)
template<>
constexpr const char *	units::name_plural (const volume::liter_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const liter_t &obj)
std::string	units::volume::to_string (const liter_t &obj)
	units::UNIT_ADD_LITERALS (volume, liter, L) UNIT_ADD(volume
femto< liters >	units::UNIT_ADD (volume, picoliter, picoliters, pL, pico< liters >) UNIT_ADD(volume
femto< liters > nano< liters >	units::UNIT_ADD (volume, microliter, microliters, uL, micro< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters >	units::UNIT_ADD (volume, centiliter, centiliters, cL, centi< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters >	units::UNIT_ADD (volume, decaliter, decaliters, daL, deca< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters >	units::UNIT_ADD (volume, kiloliter, kiloliters, kL, kilo< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters > mega< liters >	units::UNIT_ADD (volume, gigaliter, gigaliters, GL, giga< liters >) UNIT_ADD(volume
template<>
constexpr const char *	units::name (const volume::cubic_inch_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_inch_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_inch_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_inch_t &obj)
std::string	units::volume::to_string (const cubic_inch_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_foot_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_foot_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_foot_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_foot_t &obj)
std::string	units::volume::to_string (const cubic_foot_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_yard_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_yard_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_yard_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_yard_t &obj)
std::string	units::volume::to_string (const cubic_yard_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_mile_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_mile_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_mile_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_mile_t &obj)
std::string	units::volume::to_string (const cubic_mile_t &obj)
template<>
constexpr const char *	units::name (const volume::gallon_t &)
template<>
constexpr const char *	units::abbreviation (const volume::gallon_t &)
template<>
constexpr const char *	units::name_plural (const volume::gallon_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const gallon_t &obj)
std::string	units::volume::to_string (const gallon_t &obj)
template<>
constexpr const char *	units::name (const volume::quart_t &)
template<>
constexpr const char *	units::abbreviation (const volume::quart_t &)
template<>
constexpr const char *	units::name_plural (const volume::quart_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const quart_t &obj)
std::string	units::volume::to_string (const quart_t &obj)
template<>
constexpr const char *	units::name (const volume::pint_t &)
template<>
constexpr const char *	units::abbreviation (const volume::pint_t &)
template<>
constexpr const char *	units::name_plural (const volume::pint_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const pint_t &obj)
std::string	units::volume::to_string (const pint_t &obj)
template<>
constexpr const char *	units::name (const volume::cup_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cup_t &)
template<>
constexpr const char *	units::name_plural (const volume::cup_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cup_t &obj)
std::string	units::volume::to_string (const cup_t &obj)
template<>
constexpr const char *	units::name (const volume::fluid_ounce_t &)
template<>
constexpr const char *	units::abbreviation (const volume::fluid_ounce_t &)
template<>
constexpr const char *	units::name_plural (const volume::fluid_ounce_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const fluid_ounce_t &obj)
std::string	units::volume::to_string (const fluid_ounce_t &obj)
template<>
constexpr const char *	units::name (const volume::barrel_t &)
template<>
constexpr const char *	units::abbreviation (const volume::barrel_t &)
template<>
constexpr const char *	units::name_plural (const volume::barrel_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const barrel_t &obj)
std::string	units::volume::to_string (const barrel_t &obj)
template<>
constexpr const char *	units::name (const volume::bushel_t &)
template<>
constexpr const char *	units::abbreviation (const volume::bushel_t &)
template<>
constexpr const char *	units::name_plural (const volume::bushel_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const bushel_t &obj)
std::string	units::volume::to_string (const bushel_t &obj)
template<>
constexpr const char *	units::name (const volume::cord_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cord_t &)
template<>
constexpr const char *	units::name_plural (const volume::cord_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cord_t &obj)
std::string	units::volume::to_string (const cord_t &obj)
template<>
constexpr const char *	units::name (const volume::cubic_fathom_t &)
template<>
constexpr const char *	units::abbreviation (const volume::cubic_fathom_t &)
template<>
constexpr const char *	units::name_plural (const volume::cubic_fathom_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const cubic_fathom_t &obj)
std::string	units::volume::to_string (const cubic_fathom_t &obj)
template<>
constexpr const char *	units::name (const volume::tablespoon_t &)
template<>
constexpr const char *	units::abbreviation (const volume::tablespoon_t &)
template<>
constexpr const char *	units::name_plural (const volume::tablespoon_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const tablespoon_t &obj)
std::string	units::volume::to_string (const tablespoon_t &obj)
template<>
constexpr const char *	units::name (const volume::teaspoon_t &)
template<>
constexpr const char *	units::abbreviation (const volume::teaspoon_t &)
template<>
constexpr const char *	units::name_plural (const volume::teaspoon_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const teaspoon_t &obj)
std::string	units::volume::to_string (const teaspoon_t &obj)
template<>
constexpr const char *	units::name (const volume::pinch_t &)
template<>
constexpr const char *	units::abbreviation (const volume::pinch_t &)
template<>
constexpr const char *	units::name_plural (const volume::pinch_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const pinch_t &obj)
std::string	units::volume::to_string (const pinch_t &obj)
template<>
constexpr const char *	units::name (const volume::dash_t &)
template<>
constexpr const char *	units::abbreviation (const volume::dash_t &)
template<>
constexpr const char *	units::name_plural (const volume::dash_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const dash_t &obj)
std::string	units::volume::to_string (const dash_t &obj)
template<>
constexpr const char *	units::name (const volume::drop_t &)
template<>
constexpr const char *	units::abbreviation (const volume::drop_t &)
template<>
constexpr const char *	units::name_plural (const volume::drop_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const drop_t &obj)
std::string	units::volume::to_string (const drop_t &obj)
template<>
constexpr const char *	units::name (const volume::fifth_t &)
template<>
constexpr const char *	units::abbreviation (const volume::fifth_t &)
template<>
constexpr const char *	units::name_plural (const volume::fifth_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const fifth_t &obj)
std::string	units::volume::to_string (const fifth_t &obj)
template<>
constexpr const char *	units::name (const volume::dram_t &)
template<>
constexpr const char *	units::abbreviation (const volume::dram_t &)
template<>
constexpr const char *	units::name_plural (const volume::dram_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const dram_t &obj)
std::string	units::volume::to_string (const dram_t &obj)
template<>
constexpr const char *	units::name (const volume::gill_t &)
template<>
constexpr const char *	units::abbreviation (const volume::gill_t &)
template<>
constexpr const char *	units::name_plural (const volume::gill_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const gill_t &obj)
std::string	units::volume::to_string (const gill_t &obj)
template<>
constexpr const char *	units::name (const volume::peck_t &)
template<>
constexpr const char *	units::abbreviation (const volume::peck_t &)
template<>
constexpr const char *	units::name_plural (const volume::peck_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const peck_t &obj)
std::string	units::volume::to_string (const peck_t &obj)
template<>
constexpr const char *	units::name (const volume::sack_t &)
template<>
constexpr const char *	units::abbreviation (const volume::sack_t &)
template<>
constexpr const char *	units::name_plural (const volume::sack_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const sack_t &obj)
std::string	units::volume::to_string (const sack_t &obj)
template<>
constexpr const char *	units::name (const volume::shot_t &)
template<>
constexpr const char *	units::abbreviation (const volume::shot_t &)
template<>
constexpr const char *	units::name_plural (const volume::shot_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const shot_t &obj)
std::string	units::volume::to_string (const shot_t &obj)
template<>
constexpr const char *	units::name (const volume::strike_t &)
template<>
constexpr const char *	units::abbreviation (const volume::strike_t &)
template<>
constexpr const char *	units::name_plural (const volume::strike_t &)
std::ostream &	units::volume::operator<< (std::ostream &os, const strike_t &obj)
std::string	units::volume::to_string (const strike_t &obj)
	units::UNIT_ADD_LITERALS (volume, strike, strikes) namespace traits
template<>
constexpr const char *	units::name (const density::kilograms_per_cubic_meter_t &)
template<>
constexpr const char *	units::abbreviation (const density::kilograms_per_cubic_meter_t &)
template<>
constexpr const char *	units::name_plural (const density::kilograms_per_cubic_meter_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const kilograms_per_cubic_meter_t &obj)
std::string	units::density::to_string (const kilograms_per_cubic_meter_t &obj)
template<>
constexpr const char *	units::name (const density::grams_per_milliliter_t &)
template<>
constexpr const char *	units::abbreviation (const density::grams_per_milliliter_t &)
template<>
constexpr const char *	units::name_plural (const density::grams_per_milliliter_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const grams_per_milliliter_t &obj)
std::string	units::density::to_string (const grams_per_milliliter_t &obj)
template<>
constexpr const char *	units::name (const density::kilograms_per_liter_t &)
template<>
constexpr const char *	units::abbreviation (const density::kilograms_per_liter_t &)
template<>
constexpr const char *	units::name_plural (const density::kilograms_per_liter_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const kilograms_per_liter_t &obj)
std::string	units::density::to_string (const kilograms_per_liter_t &obj)
template<>
constexpr const char *	units::name (const density::ounces_per_cubic_foot_t &)
template<>
constexpr const char *	units::abbreviation (const density::ounces_per_cubic_foot_t &)
template<>
constexpr const char *	units::name_plural (const density::ounces_per_cubic_foot_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const ounces_per_cubic_foot_t &obj)
std::string	units::density::to_string (const ounces_per_cubic_foot_t &obj)
template<>
constexpr const char *	units::name (const density::ounces_per_cubic_inch_t &)
template<>
constexpr const char *	units::abbreviation (const density::ounces_per_cubic_inch_t &)
template<>
constexpr const char *	units::name_plural (const density::ounces_per_cubic_inch_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const ounces_per_cubic_inch_t &obj)
std::string	units::density::to_string (const ounces_per_cubic_inch_t &obj)
template<>
constexpr const char *	units::name (const density::ounces_per_gallon_t &)
template<>
constexpr const char *	units::abbreviation (const density::ounces_per_gallon_t &)
template<>
constexpr const char *	units::name_plural (const density::ounces_per_gallon_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const ounces_per_gallon_t &obj)
std::string	units::density::to_string (const ounces_per_gallon_t &obj)
template<>
constexpr const char *	units::name (const density::pounds_per_cubic_foot_t &)
template<>
constexpr const char *	units::abbreviation (const density::pounds_per_cubic_foot_t &)
template<>
constexpr const char *	units::name_plural (const density::pounds_per_cubic_foot_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const pounds_per_cubic_foot_t &obj)
std::string	units::density::to_string (const pounds_per_cubic_foot_t &obj)
template<>
constexpr const char *	units::name (const density::pounds_per_cubic_inch_t &)
template<>
constexpr const char *	units::abbreviation (const density::pounds_per_cubic_inch_t &)
template<>
constexpr const char *	units::name_plural (const density::pounds_per_cubic_inch_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const pounds_per_cubic_inch_t &obj)
std::string	units::density::to_string (const pounds_per_cubic_inch_t &obj)
template<>
constexpr const char *	units::name (const density::pounds_per_gallon_t &)
template<>
constexpr const char *	units::abbreviation (const density::pounds_per_gallon_t &)
template<>
constexpr const char *	units::name_plural (const density::pounds_per_gallon_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const pounds_per_gallon_t &obj)
std::string	units::density::to_string (const pounds_per_gallon_t &obj)
template<>
constexpr const char *	units::name (const density::slugs_per_cubic_foot_t &)
template<>
constexpr const char *	units::abbreviation (const density::slugs_per_cubic_foot_t &)
template<>
constexpr const char *	units::name_plural (const density::slugs_per_cubic_foot_t &)
std::ostream &	units::density::operator<< (std::ostream &os, const slugs_per_cubic_foot_t &obj)
std::string	units::density::to_string (const slugs_per_cubic_foot_t &obj)
	units::UNIT_ADD_LITERALS (density, slugs_per_cubic_foot, slug_per_cu_ft) namespace traits
template<>
constexpr const char *	units::name (const concentration::ppm_t &)
template<>
constexpr const char *	units::abbreviation (const concentration::ppm_t &)
template<>
constexpr const char *	units::name_plural (const concentration::ppm_t &)
std::ostream &	units::concentration::operator<< (std::ostream &os, const ppm_t &obj)
std::string	units::concentration::to_string (const ppm_t &obj)
template<>
constexpr const char *	units::name (const concentration::ppb_t &)
template<>
constexpr const char *	units::abbreviation (const concentration::ppb_t &)
template<>
constexpr const char *	units::name_plural (const concentration::ppb_t &)
std::ostream &	units::concentration::operator<< (std::ostream &os, const ppb_t &obj)
std::string	units::concentration::to_string (const ppb_t &obj)
template<>
constexpr const char *	units::name (const concentration::ppt_t &)
template<>
constexpr const char *	units::abbreviation (const concentration::ppt_t &)
template<>
constexpr const char *	units::name_plural (const concentration::ppt_t &)
std::ostream &	units::concentration::operator<< (std::ostream &os, const ppt_t &obj)
std::string	units::concentration::to_string (const ppt_t &obj)
template<>
constexpr const char *	units::name (const concentration::percent_t &)
template<>
constexpr const char *	units::abbreviation (const concentration::percent_t &)
template<>
constexpr const char *	units::name_plural (const concentration::percent_t &)
std::ostream &	units::concentration::operator<< (std::ostream &os, const percent_t &obj)
std::string	units::concentration::to_string (const percent_t &obj)
	units::UNIT_ADD_LITERALS (concentration, percent, pct) namespace traits
template<>
constexpr const char *	units::name (const data::byte_t &)
template<>
constexpr const char *	units::abbreviation (const data::byte_t &)
template<>
constexpr const char *	units::name_plural (const data::byte_t &)
std::ostream &	units::data::operator<< (std::ostream &os, const byte_t &obj)
std::string	units::data::to_string (const byte_t &obj)
	units::UNIT_ADD_LITERALS (data, byte, B) UNIT_ADD(data
femto< bytes >	units::UNIT_ADD (data, picobyte, picobytes, pB, pico< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes >	units::UNIT_ADD (data, microbyte, microbytes, uB, micro< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes >	units::UNIT_ADD (data, centibyte, centibytes, cB, centi< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes >	units::UNIT_ADD (data, decabyte, decabytes, daB, deca< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes >	units::UNIT_ADD (data, kilobyte, kilobytes, kB, kilo< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes >	units::UNIT_ADD (data, gigabyte, gigabytes, GB, giga< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes >	units::UNIT_ADD (data, petabyte, petabytes, PB, peta< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes >	units::UNIT_ADD (data, mebibyte, mebibytes, MiB, mebi< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes > gibi< bytes >	units::UNIT_ADD (data, tebibyte, tebibytes, TiB, tebi< bytes >) UNIT_ADD(data
template<>
constexpr const char *	units::name (const data::exabyte_t &)
template<>
constexpr const char *	units::abbreviation (const data::exabyte_t &)
template<>
constexpr const char *	units::name_plural (const data::exabyte_t &)
std::ostream &	units::data::operator<< (std::ostream &os, const exabyte_t &obj)
std::string	units::data::to_string (const exabyte_t &obj)
template<>
constexpr const char *	units::name (const data::bit_t &)
template<>
constexpr const char *	units::abbreviation (const data::bit_t &)
template<>
constexpr const char *	units::name_plural (const data::bit_t &)
std::ostream &	units::data::operator<< (std::ostream &os, const bit_t &obj)
std::string	units::data::to_string (const bit_t &obj)
	units::UNIT_ADD_LITERALS (data, bit, b) UNIT_ADD(data
femto< bits >	units::UNIT_ADD (data, picobit, picobits, pb, pico< bits >) UNIT_ADD(data
femto< bits > nano< bits >	units::UNIT_ADD (data, microbit, microbits, ub, micro< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits >	units::UNIT_ADD (data, centibit, centibits, cb, centi< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits >	units::UNIT_ADD (data, decabit, decabits, dab, deca< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits >	units::UNIT_ADD (data, kilobit, kilobits, kb, kilo< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits >	units::UNIT_ADD (data, gigabit, gigabits, Gb, giga< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits >	units::UNIT_ADD (data, petabit, petabits, Pb, peta< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits >	units::UNIT_ADD (data, mebibit, mebibits, Mib, mebi< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits > gibi< bits >	units::UNIT_ADD (data, tebibit, tebibits, Tib, tebi< bits >) UNIT_ADD(data
template<>
constexpr const char *	units::name (const data::exabit_t &)
template<>
constexpr const char *	units::abbreviation (const data::exabit_t &)
template<>
constexpr const char *	units::name_plural (const data::exabit_t &)
std::ostream &	units::data::operator<< (std::ostream &os, const exabit_t &obj)
std::string	units::data::to_string (const exabit_t &obj)
	units::UNIT_ADD_LITERALS (data, exabit, Eb) namespace traits
template<>
constexpr const char *	units::name (const data_transfer_rate::bytes_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const data_transfer_rate::bytes_per_second_t &)
template<>
constexpr const char *	units::name_plural (const data_transfer_rate::bytes_per_second_t &)
std::ostream &	units::data_transfer_rate::operator<< (std::ostream &os, const bytes_per_second_t &obj)
std::string	units::data_transfer_rate::to_string (const bytes_per_second_t &obj)
	units::UNIT_ADD_LITERALS (data_transfer_rate, bytes_per_second, Bps) UNIT_ADD(data_transfer_rate
femto< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, picobytes_per_second, picobytes_per_second, pBps, pico< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, microbytes_per_second, microbytes_per_second, uBps, micro< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, centibytes_per_second, centibytes_per_second, cBps, centi< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, decabytes_per_second, decabytes_per_second, daBps, deca< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, kilobytes_per_second, kilobytes_per_second, kBps, kilo< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, gigabytes_per_second, gigabytes_per_second, GBps, giga< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, petabytes_per_second, petabytes_per_second, PBps, peta< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, mebibytes_per_second, mebibytes_per_second, MiBps, mebi< bytes_per_second >) UNIT_ADD(data_transfer_rate
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second > gibi< bytes_per_second >	units::UNIT_ADD (data_transfer_rate, tebibytes_per_second, tebibytes_per_second, TiBps, tebi< bytes_per_second >) UNIT_ADD(data_transfer_rate
template<>
constexpr const char *	units::name (const data_transfer_rate::exabytes_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const data_transfer_rate::exabytes_per_second_t &)
template<>
constexpr const char *	units::name_plural (const data_transfer_rate::exabytes_per_second_t &)
std::ostream &	units::data_transfer_rate::operator<< (std::ostream &os, const exabytes_per_second_t &obj)
std::string	units::data_transfer_rate::to_string (const exabytes_per_second_t &obj)
template<>
constexpr const char *	units::name (const data_transfer_rate::bits_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const data_transfer_rate::bits_per_second_t &)
template<>
constexpr const char *	units::name_plural (const data_transfer_rate::bits_per_second_t &)
std::ostream &	units::data_transfer_rate::operator<< (std::ostream &os, const bits_per_second_t &obj)
std::string	units::data_transfer_rate::to_string (const bits_per_second_t &obj)
	units::UNIT_ADD_LITERALS (data_transfer_rate, bits_per_second, bps) UNIT_ADD(data_transfer_rate
femto< bits_per_second >	units::UNIT_ADD (data_transfer_rate, picobits_per_second, picobits_per_second, pbps, pico< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second >	units::UNIT_ADD (data_transfer_rate, microbits_per_second, microbits_per_second, ubps, micro< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second >	units::UNIT_ADD (data_transfer_rate, centibits_per_second, centibits_per_second, cbps, centi< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second >	units::UNIT_ADD (data_transfer_rate, decabits_per_second, decabits_per_second, dabps, deca< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second >	units::UNIT_ADD (data_transfer_rate, kilobits_per_second, kilobits_per_second, kbps, kilo< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second >	units::UNIT_ADD (data_transfer_rate, gigabits_per_second, gigabits_per_second, Gbps, giga< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second >	units::UNIT_ADD (data_transfer_rate, petabits_per_second, petabits_per_second, Pbps, peta< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second >	units::UNIT_ADD (data_transfer_rate, mebibits_per_second, mebibits_per_second, Mibps, mebi< bits_per_second >) UNIT_ADD(data_transfer_rate
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second > gibi< bits_per_second >	units::UNIT_ADD (data_transfer_rate, tebibits_per_second, tebibits_per_second, Tibps, tebi< bits_per_second >) UNIT_ADD(data_transfer_rate
template<>
constexpr const char *	units::name (const data_transfer_rate::exabits_per_second_t &)
template<>
constexpr const char *	units::abbreviation (const data_transfer_rate::exabits_per_second_t &)
template<>
constexpr const char *	units::name_plural (const data_transfer_rate::exabits_per_second_t &)
std::ostream &	units::data_transfer_rate::operator<< (std::ostream &os, const exabits_per_second_t &obj)
std::string	units::data_transfer_rate::to_string (const exabits_per_second_t &obj)
	units::UNIT_ADD_LITERALS (data_transfer_rate, exabits_per_second, Ebps) namespace traits
template<class UnitTypeLhs, class UnitTypeRhs>
UnitTypeLhs	units::math::min (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
template<class UnitTypeLhs, class UnitTypeRhs>
UnitTypeLhs	units::math::max (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs)
template<class AngleUnit>
dimensionless::scalar_t	units::math::cos (const AngleUnit angle) noexcept
	Compute cosine.
template<class AngleUnit>
dimensionless::scalar_t	units::math::sin (const AngleUnit angle) noexcept
	Compute sine.
template<class AngleUnit>
dimensionless::scalar_t	units::math::tan (const AngleUnit angle) noexcept
	Compute tangent.
template<class ScalarUnit>
angle::radian_t	units::math::acos (const ScalarUnit x) noexcept
	Compute arc cosine.
template<class ScalarUnit>
angle::radian_t	units::math::asin (const ScalarUnit x) noexcept
	Compute arc sine.
template<class ScalarUnit>
angle::radian_t	units::math::atan (const ScalarUnit x) noexcept
	Compute arc tangent.
template<class Y, class X>
angle::radian_t	units::math::atan2 (const Y y, const X x) noexcept
	Compute arc tangent with two parameters.
template<class AngleUnit>
dimensionless::scalar_t	units::math::cosh (const AngleUnit angle) noexcept
	Compute hyperbolic cosine.
template<class AngleUnit>
dimensionless::scalar_t	units::math::sinh (const AngleUnit angle) noexcept
	Compute hyperbolic sine.
template<class AngleUnit>
dimensionless::scalar_t	units::math::tanh (const AngleUnit angle) noexcept
	Compute hyperbolic tangent.
template<class ScalarUnit>
angle::radian_t	units::math::acosh (const ScalarUnit x) noexcept
	Compute arc hyperbolic cosine.
template<class ScalarUnit>
angle::radian_t	units::math::asinh (const ScalarUnit x) noexcept
	Compute arc hyperbolic sine.
template<class ScalarUnit>
angle::radian_t	units::math::atanh (const ScalarUnit x) noexcept
	Compute arc hyperbolic tangent.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::exp (const ScalarUnit x) noexcept
	Compute exponential function.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::log (const ScalarUnit x) noexcept
	Compute natural logarithm.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::log10 (const ScalarUnit x) noexcept
	Compute common logarithm.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::modf (const ScalarUnit x, ScalarUnit *intpart) noexcept
	Break into fractional and integral parts.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::exp2 (const ScalarUnit x) noexcept
	Compute binary exponential function.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::expm1 (const ScalarUnit x) noexcept
	Compute exponential minus one.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::log1p (const ScalarUnit x) noexcept
	Compute logarithm plus one.
template<class ScalarUnit>
dimensionless::scalar_t	units::math::log2 (const ScalarUnit x) noexcept
	Compute binary logarithm.
template<class UnitType, std::enable_if_t< units::traits::has_linear_scale< UnitType >::value, int > = 0>
auto	units::math::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 >
	computes the square root of value
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< units::traits::has_linear_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
UnitTypeLhs	units::math::hypot (const UnitTypeLhs &x, const UnitTypeRhs &y)
	Computes the square root of the sum-of-squares of x and y.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::ceil (const UnitType x) noexcept
	Round up value.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::floor (const UnitType x) noexcept
	Round down value.
template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
UnitTypeLhs	units::math::fmod (const UnitTypeLhs numer, const UnitTypeRhs denom) noexcept
	Compute remainder of division.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::trunc (const UnitType x) noexcept
	Truncate value.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::round (const UnitType x) noexcept
	Round to nearest.
template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
UnitTypeLhs	units::math::copysign (const UnitTypeLhs x, const UnitTypeRhs y) noexcept
	Copy sign.
template<class UnitTypeLhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value>>
UnitTypeLhs	units::math::copysign (const UnitTypeLhs x, const double y) noexcept
	Overload to copy the sign from a raw double.
template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
UnitTypeLhs	units::math::fdim (const UnitTypeLhs x, const UnitTypeRhs y) noexcept
	Positive difference.
template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
UnitTypeLhs	units::math::fmax (const UnitTypeLhs x, const UnitTypeRhs y) noexcept
	Maximum value.
template<class UnitTypeLhs, class UnitTypeRhs, class = std::enable_if_t<traits::is_unit_t<UnitTypeLhs>::value && traits::is_unit_t<UnitTypeRhs>::value>>
UnitTypeLhs	units::math::fmin (const UnitTypeLhs x, const UnitTypeRhs y) noexcept
	Minimum value.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::fabs (const UnitType x) noexcept
	Compute absolute value.
template<class UnitType, class = std::enable_if_t<traits::is_unit_t<UnitType>::value>>
UnitType	units::math::abs (const UnitType x) noexcept
	Compute absolute value.
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	units::math::fma (const UnitTypeLhs x, const UnitMultiply y, const UnitAdd z) noexcept -> decltype(x *y)
	Multiply-add.
template<class Units, typename T, template< typename > class NonLinearScale>
bool	std::isnan (const units::unit_t< Units, T, NonLinearScale > &x)
template<class Units, typename T, template< typename > class NonLinearScale>
bool	std::isinf (const units::unit_t< Units, T, NonLinearScale > &x)
template<class Units, typename T, template< typename > class NonLinearScale>
bool	std::signbit (const units::unit_t< Units, T, NonLinearScale > &x)

Variables
	units::femtometer
	units::femtometers
	units::fm
femto< meters >	units::nanometer
femto< meters >	units::nanometers
femto< meters >	units::nm
femto< meters > nano< meters >	units::millimeter
femto< meters > nano< meters >	units::millimeters
femto< meters > nano< meters >	units::mm
femto< meters > nano< meters > milli< meters >	units::decimeter
femto< meters > nano< meters > milli< meters >	units::decimeters
femto< meters > nano< meters > milli< meters >	units::dm
femto< meters > nano< meters > milli< meters > deci< meters >	units::hectometer
femto< meters > nano< meters > milli< meters > deci< meters >	units::hectometers
femto< meters > nano< meters > milli< meters > deci< meters >	units::hm
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters >	units::megameter
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters >	units::megameters
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters >	units::Mm
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters > mega< meters >	units::terameter
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters > mega< meters >	units::terameters
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters > mega< meters >	units::Tm
	units::femtogram
	units::femtograms
	units::fg
femto< grams >	units::nanogram
femto< grams >	units::nanograms
femto< grams >	units::ng
femto< grams > nano< grams >	units::milligram
femto< grams > nano< grams >	units::milligrams
femto< grams > nano< grams >	units::mg
femto< grams > nano< grams > milli< grams >	units::decigram
femto< grams > nano< grams > milli< grams >	units::decigrams
femto< grams > nano< grams > milli< grams >	units::dg
femto< grams > nano< grams > milli< grams > deci< grams >	units::hectogram
femto< grams > nano< grams > milli< grams > deci< grams >	units::hectograms
femto< grams > nano< grams > milli< grams > deci< grams >	units::hg
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams >	units::megagram
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams >	units::megagrams
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams >	units::Mg
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams > mega< grams >	units::teragram
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams > mega< grams >	units::teragrams
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams > mega< grams >	units::Tg
	units::femtosecond
	units::femtoseconds
	units::fs
femto< seconds >	units::nanosecond
femto< seconds >	units::nanoseconds
femto< seconds >	units::ns
femto< seconds > nano< seconds >	units::millisecond
femto< seconds > nano< seconds >	units::milliseconds
femto< seconds > nano< seconds >	units::ms
femto< seconds > nano< seconds > milli< seconds >	units::decisecond
femto< seconds > nano< seconds > milli< seconds >	units::deciseconds
femto< seconds > nano< seconds > milli< seconds >	units::ds
femto< seconds > nano< seconds > milli< seconds > deci< seconds >	units::hectosecond
femto< seconds > nano< seconds > milli< seconds > deci< seconds >	units::hectoseconds
femto< seconds > nano< seconds > milli< seconds > deci< seconds >	units::hs
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds >	units::megasecond
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds >	units::megaseconds
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds >	units::Ms
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds > mega< seconds >	units::terasecond
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds > mega< seconds >	units::teraseconds
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds > mega< seconds >	units::Ts
	units::femtoradian
	units::femtoradians
	units::frad
femto< radians >	units::nanoradian
femto< radians >	units::nanoradians
femto< radians >	units::nrad
femto< radians > nano< radians >	units::milliradian
femto< radians > nano< radians >	units::milliradians
femto< radians > nano< radians >	units::mrad
femto< radians > nano< radians > milli< radians >	units::deciradian
femto< radians > nano< radians > milli< radians >	units::deciradians
femto< radians > nano< radians > milli< radians >	units::drad
femto< radians > nano< radians > milli< radians > deci< radians >	units::hectoradian
femto< radians > nano< radians > milli< radians > deci< radians >	units::hectoradians
femto< radians > nano< radians > milli< radians > deci< radians >	units::hrad
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians >	units::megaradian
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians >	units::megaradians
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians >	units::Mrad
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians > mega< radians >	units::teraradian
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians > mega< radians >	units::teraradians
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians > mega< radians >	units::Trad
	units::femtoampere
	units::femtoamperes
	units::fA
femto< amperes >	units::nanoampere
femto< amperes >	units::nanoamperes
femto< amperes >	units::nA
femto< amperes > nano< amperes >	units::milliampere
femto< amperes > nano< amperes >	units::milliamperes
femto< amperes > nano< amperes >	units::mA
femto< amperes > nano< amperes > milli< amperes >	units::deciampere
femto< amperes > nano< amperes > milli< amperes >	units::deciamperes
femto< amperes > nano< amperes > milli< amperes >	units::dA
femto< amperes > nano< amperes > milli< amperes > deci< amperes >	units::hectoampere
femto< amperes > nano< amperes > milli< amperes > deci< amperes >	units::hectoamperes
femto< amperes > nano< amperes > milli< amperes > deci< amperes >	units::hA
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes >	units::megaampere
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes >	units::megaamperes
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes >	units::MA
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes >	units::teraampere
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes >	units::teraamperes
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes >	units::TA
	units::femtocandela
	units::femtocandelas
	units::fcd
femto< candelas >	units::nanocandela
femto< candelas >	units::nanocandelas
femto< candelas >	units::ncd
femto< candelas > nano< candelas >	units::millicandela
femto< candelas > nano< candelas >	units::millicandelas
femto< candelas > nano< candelas >	units::mcd
femto< candelas > nano< candelas > milli< candelas >	units::decicandela
femto< candelas > nano< candelas > milli< candelas >	units::decicandelas
femto< candelas > nano< candelas > milli< candelas >	units::dcd
femto< candelas > nano< candelas > milli< candelas > deci< candelas >	units::hectocandela
femto< candelas > nano< candelas > milli< candelas > deci< candelas >	units::hectocandelas
femto< candelas > nano< candelas > milli< candelas > deci< candelas >	units::hcd
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas >	units::megacandela
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas >	units::megacandelas
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas >	units::Mcd
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas >	units::teracandela
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas >	units::teracandelas
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas >	units::Tcd
	units::femtosteradian
	units::femtosteradians
	units::fsr
femto< steradians >	units::nanosteradian
femto< steradians >	units::nanosteradians
femto< steradians >	units::nsr
femto< steradians > nano< steradians >	units::millisteradian
femto< steradians > nano< steradians >	units::millisteradians
femto< steradians > nano< steradians >	units::msr
femto< steradians > nano< steradians > milli< steradians >	units::decisteradian
femto< steradians > nano< steradians > milli< steradians >	units::decisteradians
femto< steradians > nano< steradians > milli< steradians >	units::dsr
femto< steradians > nano< steradians > milli< steradians > deci< steradians >	units::hectosteradian
femto< steradians > nano< steradians > milli< steradians > deci< steradians >	units::hectosteradians
femto< steradians > nano< steradians > milli< steradians > deci< steradians >	units::hsr
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians >	units::megasteradian
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians >	units::megasteradians
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians >	units::Msr
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians > mega< steradians >	units::terasteradian
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians > mega< steradians >	units::terasteradians
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians > mega< steradians >	units::Tsr
	units::femtohertz
	units::fHz
femto< hertz >	units::nanohertz
femto< hertz >	units::nHz
femto< hertz > nano< hertz >	units::millihertz
femto< hertz > nano< hertz >	units::mHz
femto< hertz > nano< hertz > milli< hertz >	units::decihertz
femto< hertz > nano< hertz > milli< hertz >	units::dHz
femto< hertz > nano< hertz > milli< hertz > deci< hertz >	units::hectohertz
femto< hertz > nano< hertz > milli< hertz > deci< hertz >	units::hHz
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz >	units::megahertz
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz >	units::MHz
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz >	units::terahertz
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz >	units::THz
	units::femtonewton
	units::femtonewtons
	units::fN
femto< newtons >	units::nanonewton
femto< newtons >	units::nanonewtons
femto< newtons >	units::nN
femto< newtons > nano< newtons >	units::millinewton
femto< newtons > nano< newtons >	units::millinewtons
femto< newtons > nano< newtons >	units::mN
femto< newtons > nano< newtons > milli< newtons >	units::decinewton
femto< newtons > nano< newtons > milli< newtons >	units::decinewtons
femto< newtons > nano< newtons > milli< newtons >	units::dN
femto< newtons > nano< newtons > milli< newtons > deci< newtons >	units::hectonewton
femto< newtons > nano< newtons > milli< newtons > deci< newtons >	units::hectonewtons
femto< newtons > nano< newtons > milli< newtons > deci< newtons >	units::hN
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons >	units::meganewton
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons >	units::meganewtons
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons >	units::MN
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons > mega< newtons >	units::teranewton
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons > mega< newtons >	units::teranewtons
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons > mega< newtons >	units::TN
	units::femtopascal
	units::femtopascals
	units::fPa
femto< pascals >	units::nanopascal
femto< pascals >	units::nanopascals
femto< pascals >	units::nPa
femto< pascals > nano< pascals >	units::millipascal
femto< pascals > nano< pascals >	units::millipascals
femto< pascals > nano< pascals >	units::mPa
femto< pascals > nano< pascals > milli< pascals >	units::decipascal
femto< pascals > nano< pascals > milli< pascals >	units::decipascals
femto< pascals > nano< pascals > milli< pascals >	units::dPa
femto< pascals > nano< pascals > milli< pascals > deci< pascals >	units::hectopascal
femto< pascals > nano< pascals > milli< pascals > deci< pascals >	units::hectopascals
femto< pascals > nano< pascals > milli< pascals > deci< pascals >	units::hPa
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals >	units::megapascal
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals >	units::megapascals
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals >	units::MPa
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals > mega< pascals >	units::terapascal
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals > mega< pascals >	units::terapascals
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals > mega< pascals >	units::TPa
	units::femtocoulomb
	units::femtocoulombs
	units::fC
femto< coulombs >	units::nanocoulomb
femto< coulombs >	units::nanocoulombs
femto< coulombs >	units::nC
femto< coulombs > nano< coulombs >	units::millicoulomb
femto< coulombs > nano< coulombs >	units::millicoulombs
femto< coulombs > nano< coulombs >	units::mC
femto< coulombs > nano< coulombs > milli< coulombs >	units::decicoulomb
femto< coulombs > nano< coulombs > milli< coulombs >	units::decicoulombs
femto< coulombs > nano< coulombs > milli< coulombs >	units::dC
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs >	units::hectocoulomb
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs >	units::hectocoulombs
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs >	units::hC
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs >	units::megacoulomb
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs >	units::megacoulombs
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs >	units::MC
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs > mega< coulombs >	units::teracoulomb
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs > mega< coulombs >	units::teracoulombs
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs > mega< coulombs >	units::TC
	units::femtoampere_hour
	units::femtoampere_hours
	units::fAh
femto< ampere_hours >	units::nanoampere_hour
femto< ampere_hours >	units::nanoampere_hours
femto< ampere_hours >	units::nAh
femto< ampere_hours > nano< ampere_hours >	units::milliampere_hour
femto< ampere_hours > nano< ampere_hours >	units::milliampere_hours
femto< ampere_hours > nano< ampere_hours >	units::mAh
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours >	units::deciampere_hour
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours >	units::deciampere_hours
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours >	units::dAh
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours >	units::hectoampere_hour
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours >	units::hectoampere_hours
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours >	units::hAh
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours >	units::megaampere_hour
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours >	units::megaampere_hours
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours >	units::MAh
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours > mega< ampere_hours >	units::teraampere_hour
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours > mega< ampere_hours >	units::teraampere_hours
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours > deci< ampere_hours > hecto< ampere_hours > mega< ampere_hours >	units::TAh
	units::femtojoule
	units::femtojoules
	units::fJ
femto< joules >	units::nanojoule
femto< joules >	units::nanojoules
femto< joules >	units::nJ
femto< joules > nano< joules >	units::millijoule
femto< joules > nano< joules >	units::millijoules
femto< joules > nano< joules >	units::mJ
femto< joules > nano< joules > milli< joules >	units::decijoule
femto< joules > nano< joules > milli< joules >	units::decijoules
femto< joules > nano< joules > milli< joules >	units::dJ
femto< joules > nano< joules > milli< joules > deci< joules >	units::hectojoule
femto< joules > nano< joules > milli< joules > deci< joules >	units::hectojoules
femto< joules > nano< joules > milli< joules > deci< joules >	units::hJ
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules >	units::megajoule
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules >	units::megajoules
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules >	units::MJ
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules > mega< joules >	units::terajoule
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules > mega< joules >	units::terajoules
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules > mega< joules >	units::TJ
	units::femtocalorie
	units::femtocalories
	units::fcal
femto< calories >	units::nanocalorie
femto< calories >	units::nanocalories
femto< calories >	units::ncal
femto< calories > nano< calories >	units::millicalorie
femto< calories > nano< calories >	units::millicalories
femto< calories > nano< calories >	units::mcal
femto< calories > nano< calories > milli< calories >	units::decicalorie
femto< calories > nano< calories > milli< calories >	units::decicalories
femto< calories > nano< calories > milli< calories >	units::dcal
femto< calories > nano< calories > milli< calories > deci< calories >	units::hectocalorie
femto< calories > nano< calories > milli< calories > deci< calories >	units::hectocalories
femto< calories > nano< calories > milli< calories > deci< calories >	units::hcal
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories >	units::megacalorie
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories >	units::megacalories
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories >	units::Mcal
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories > mega< calories >	units::teracalorie
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories > mega< calories >	units::teracalories
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories > mega< calories >	units::Tcal
	units::femtowatt
	units::femtowatts
	units::fW
femto< watts >	units::nanowatt
femto< watts >	units::nanowatts
femto< watts >	units::nW
femto< watts > nano< watts >	units::milliwatt
femto< watts > nano< watts >	units::milliwatts
femto< watts > nano< watts >	units::mW
femto< watts > nano< watts > milli< watts >	units::deciwatt
femto< watts > nano< watts > milli< watts >	units::deciwatts
femto< watts > nano< watts > milli< watts >	units::dW
femto< watts > nano< watts > milli< watts > deci< watts >	units::hectowatt
femto< watts > nano< watts > milli< watts > deci< watts >	units::hectowatts
femto< watts > nano< watts > milli< watts > deci< watts >	units::hW
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts >	units::megawatt
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts >	units::megawatts
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts >	units::MW
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts > mega< watts >	units::terawatt
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts > mega< watts >	units::terawatts
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts > mega< watts >	units::TW
	units::femtovolt
	units::femtovolts
	units::fV
femto< volts >	units::nanovolt
femto< volts >	units::nanovolts
femto< volts >	units::nV
femto< volts > nano< volts >	units::millivolt
femto< volts > nano< volts >	units::millivolts
femto< volts > nano< volts >	units::mV
femto< volts > nano< volts > milli< volts >	units::decivolt
femto< volts > nano< volts > milli< volts >	units::decivolts
femto< volts > nano< volts > milli< volts >	units::dV
femto< volts > nano< volts > milli< volts > deci< volts >	units::hectovolt
femto< volts > nano< volts > milli< volts > deci< volts >	units::hectovolts
femto< volts > nano< volts > milli< volts > deci< volts >	units::hV
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts >	units::megavolt
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts >	units::megavolts
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts >	units::MV
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts > mega< volts >	units::teravolt
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts > mega< volts >	units::teravolts
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts > mega< volts >	units::TV
	units::femtofarad
	units::femtofarads
	units::fF
femto< farads >	units::nanofarad
femto< farads >	units::nanofarads
femto< farads >	units::nF
femto< farads > nano< farads >	units::millifarad
femto< farads > nano< farads >	units::millifarads
femto< farads > nano< farads >	units::mF
femto< farads > nano< farads > milli< farads >	units::decifarad
femto< farads > nano< farads > milli< farads >	units::decifarads
femto< farads > nano< farads > milli< farads >	units::dF
femto< farads > nano< farads > milli< farads > deci< farads >	units::hectofarad
femto< farads > nano< farads > milli< farads > deci< farads >	units::hectofarads
femto< farads > nano< farads > milli< farads > deci< farads >	units::hF
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads >	units::megafarad
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads >	units::megafarads
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads >	units::MF
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads >	units::terafarad
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads >	units::terafarads
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads >	units::TF
	units::femtoohm
	units::femtoohms
	units::fOhm
femto< ohms >	units::nanoohm
femto< ohms >	units::nanoohms
femto< ohms >	units::nOhm
femto< ohms > nano< ohms >	units::milliohm
femto< ohms > nano< ohms >	units::milliohms
femto< ohms > nano< ohms >	units::mOhm
femto< ohms > nano< ohms > milli< ohms >	units::deciohm
femto< ohms > nano< ohms > milli< ohms >	units::deciohms
femto< ohms > nano< ohms > milli< ohms >	units::dOhm
femto< ohms > nano< ohms > milli< ohms > deci< ohms >	units::hectoohm
femto< ohms > nano< ohms > milli< ohms > deci< ohms >	units::hectoohms
femto< ohms > nano< ohms > milli< ohms > deci< ohms >	units::hOhm
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms >	units::megaohm
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms >	units::megaohms
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms >	units::MOhm
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms >	units::teraohm
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms >	units::teraohms
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms >	units::TOhm
	units::femtosiemens
	units::fS
femto< siemens >	units::nanosiemens
femto< siemens >	units::nS
femto< siemens > nano< siemens >	units::millisiemens
femto< siemens > nano< siemens >	units::mS
femto< siemens > nano< siemens > milli< siemens >	units::decisiemens
femto< siemens > nano< siemens > milli< siemens >	units::dS
femto< siemens > nano< siemens > milli< siemens > deci< siemens >	units::hectosiemens
femto< siemens > nano< siemens > milli< siemens > deci< siemens >	units::hS
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens >	units::megasiemens
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens >	units::MS
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens >	units::terasiemens
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens >	units::TS
	units::femtoweber
	units::femtowebers
	units::fWb
femto< webers >	units::nanoweber
femto< webers >	units::nanowebers
femto< webers >	units::nWb
femto< webers > nano< webers >	units::milliweber
femto< webers > nano< webers >	units::milliwebers
femto< webers > nano< webers >	units::mWb
femto< webers > nano< webers > milli< webers >	units::deciweber
femto< webers > nano< webers > milli< webers >	units::deciwebers
femto< webers > nano< webers > milli< webers >	units::dWb
femto< webers > nano< webers > milli< webers > deci< webers >	units::hectoweber
femto< webers > nano< webers > milli< webers > deci< webers >	units::hectowebers
femto< webers > nano< webers > milli< webers > deci< webers >	units::hWb
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers >	units::megaweber
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers >	units::megawebers
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers >	units::MWb
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers > mega< webers >	units::teraweber
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers > mega< webers >	units::terawebers
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers > mega< webers >	units::TWb
	units::femtotesla
	units::femtoteslas
	units::fTe
femto< teslas >	units::nanotesla
femto< teslas >	units::nanoteslas
femto< teslas >	units::nTe
femto< teslas > nano< teslas >	units::millitesla
femto< teslas > nano< teslas >	units::milliteslas
femto< teslas > nano< teslas >	units::mTe
femto< teslas > nano< teslas > milli< teslas >	units::decitesla
femto< teslas > nano< teslas > milli< teslas >	units::deciteslas
femto< teslas > nano< teslas > milli< teslas >	units::dTe
femto< teslas > nano< teslas > milli< teslas > deci< teslas >	units::hectotesla
femto< teslas > nano< teslas > milli< teslas > deci< teslas >	units::hectoteslas
femto< teslas > nano< teslas > milli< teslas > deci< teslas >	units::hTe
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas >	units::megatesla
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas >	units::megateslas
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas >	units::MTe
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas > mega< teslas >	units::teratesla
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas > mega< teslas >	units::terateslas
femto< teslas > nano< teslas > milli< teslas > deci< teslas > hecto< teslas > mega< teslas >	units::TTe
	units::femtohenry
	units::femtohenries
	units::fH
femto< henries >	units::nanohenry
femto< henries >	units::nanohenries
femto< henries >	units::nH
femto< henries > nano< henries >	units::millihenry
femto< henries > nano< henries >	units::millihenries
femto< henries > nano< henries >	units::mH
femto< henries > nano< henries > milli< henries >	units::decihenry
femto< henries > nano< henries > milli< henries >	units::decihenries
femto< henries > nano< henries > milli< henries >	units::dH
femto< henries > nano< henries > milli< henries > deci< henries >	units::hectohenry
femto< henries > nano< henries > milli< henries > deci< henries >	units::hectohenries
femto< henries > nano< henries > milli< henries > deci< henries >	units::hH
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries >	units::megahenry
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries >	units::megahenries
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries >	units::MH
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries >	units::terahenry
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries >	units::terahenries
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries >	units::TH
	units::femtolumen
	units::femtolumens
	units::flm
femto< lumens >	units::nanolumen
femto< lumens >	units::nanolumens
femto< lumens >	units::nlm
femto< lumens > nano< lumens >	units::millilumen
femto< lumens > nano< lumens >	units::millilumens
femto< lumens > nano< lumens >	units::mlm
femto< lumens > nano< lumens > milli< lumens >	units::decilumen
femto< lumens > nano< lumens > milli< lumens >	units::decilumens
femto< lumens > nano< lumens > milli< lumens >	units::dlm
femto< lumens > nano< lumens > milli< lumens > deci< lumens >	units::hectolumen
femto< lumens > nano< lumens > milli< lumens > deci< lumens >	units::hectolumens
femto< lumens > nano< lumens > milli< lumens > deci< lumens >	units::hlm
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens >	units::megalumen
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens >	units::megalumens
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens >	units::Mlm
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens >	units::teralumen
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens >	units::teralumens
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens >	units::Tlm
	units::femtolux
	units::femtoluxes
	units::flx
femto< luxes >	units::nanolux
femto< luxes >	units::nanoluxes
femto< luxes >	units::nlx
femto< luxes > nano< luxes >	units::millilux
femto< luxes > nano< luxes >	units::milliluxes
femto< luxes > nano< luxes >	units::mlx
femto< luxes > nano< luxes > milli< luxes >	units::decilux
femto< luxes > nano< luxes > milli< luxes >	units::deciluxes
femto< luxes > nano< luxes > milli< luxes >	units::dlx
femto< luxes > nano< luxes > milli< luxes > deci< luxes >	units::hectolux
femto< luxes > nano< luxes > milli< luxes > deci< luxes >	units::hectoluxes
femto< luxes > nano< luxes > milli< luxes > deci< luxes >	units::hlx
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes >	units::megalux
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes >	units::megaluxes
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes >	units::Mlx
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes > mega< luxes >	units::teralux
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes > mega< luxes >	units::teraluxes
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes > mega< luxes >	units::Tlx
	units::femtobecquerel
	units::femtobecquerels
	units::fBq
femto< becquerels >	units::nanobecquerel
femto< becquerels >	units::nanobecquerels
femto< becquerels >	units::nBq
femto< becquerels > nano< becquerels >	units::millibecquerel
femto< becquerels > nano< becquerels >	units::millibecquerels
femto< becquerels > nano< becquerels >	units::mBq
femto< becquerels > nano< becquerels > milli< becquerels >	units::decibecquerel
femto< becquerels > nano< becquerels > milli< becquerels >	units::decibecquerels
femto< becquerels > nano< becquerels > milli< becquerels >	units::dBq
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels >	units::hectobecquerel
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels >	units::hectobecquerels
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels >	units::hBq
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels >	units::megabecquerel
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels >	units::megabecquerels
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels >	units::MBq
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels > mega< becquerels >	units::terabecquerel
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels > mega< becquerels >	units::terabecquerels
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels > mega< becquerels >	units::TBq
	units::femtogray
	units::femtograys
	units::fGy
femto< grays >	units::nanogray
femto< grays >	units::nanograys
femto< grays >	units::nGy
femto< grays > nano< grays >	units::milligray
femto< grays > nano< grays >	units::milligrays
femto< grays > nano< grays >	units::mGy
femto< grays > nano< grays > milli< grays >	units::decigray
femto< grays > nano< grays > milli< grays >	units::decigrays
femto< grays > nano< grays > milli< grays >	units::dGy
femto< grays > nano< grays > milli< grays > deci< grays >	units::hectogray
femto< grays > nano< grays > milli< grays > deci< grays >	units::hectograys
femto< grays > nano< grays > milli< grays > deci< grays >	units::hGy
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays >	units::megagray
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays >	units::megagrays
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays >	units::MGy
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays > mega< grays >	units::teragray
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays > mega< grays >	units::teragrays
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays > mega< grays >	units::TGy
	units::femtosievert
	units::femtosieverts
	units::fSv
femto< sieverts >	units::nanosievert
femto< sieverts >	units::nanosieverts
femto< sieverts >	units::nSv
femto< sieverts > nano< sieverts >	units::millisievert
femto< sieverts > nano< sieverts >	units::millisieverts
femto< sieverts > nano< sieverts >	units::mSv
femto< sieverts > nano< sieverts > milli< sieverts >	units::decisievert
femto< sieverts > nano< sieverts > milli< sieverts >	units::decisieverts
femto< sieverts > nano< sieverts > milli< sieverts >	units::dSv
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts >	units::hectosievert
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts >	units::hectosieverts
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts >	units::hSv
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts >	units::megasievert
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts >	units::megasieverts
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts >	units::MSv
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts > mega< sieverts >	units::terasievert
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts > mega< sieverts >	units::terasieverts
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts > mega< sieverts >	units::TSv
	units::femtoliter
	units::femtoliters
	units::fL
femto< liters >	units::nanoliter
femto< liters >	units::nanoliters
femto< liters >	units::nL
femto< liters > nano< liters >	units::milliliter
femto< liters > nano< liters >	units::milliliters
femto< liters > nano< liters >	units::mL
femto< liters > nano< liters > milli< liters >	units::deciliter
femto< liters > nano< liters > milli< liters >	units::deciliters
femto< liters > nano< liters > milli< liters >	units::dL
femto< liters > nano< liters > milli< liters > deci< liters >	units::hectoliter
femto< liters > nano< liters > milli< liters > deci< liters >	units::hectoliters
femto< liters > nano< liters > milli< liters > deci< liters >	units::hL
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters >	units::megaliter
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters >	units::megaliters
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters >	units::ML
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters > mega< liters >	units::teraliter
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters > mega< liters >	units::teraliters
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters > mega< liters >	units::TL
	units::femtobyte
	units::femtobytes
	units::fB
femto< bytes >	units::nanobyte
femto< bytes >	units::nanobytes
femto< bytes >	units::nB
femto< bytes > nano< bytes >	units::millibyte
femto< bytes > nano< bytes >	units::millibytes
femto< bytes > nano< bytes >	units::mB
femto< bytes > nano< bytes > milli< bytes >	units::decibyte
femto< bytes > nano< bytes > milli< bytes >	units::decibytes
femto< bytes > nano< bytes > milli< bytes >	units::dB
femto< bytes > nano< bytes > milli< bytes > deci< bytes >	units::hectobyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes >	units::hectobytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes >	units::hB
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes >	units::megabyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes >	units::megabytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes >	units::MB
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes >	units::terabyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes >	units::terabytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes >	units::TB
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes >	units::kibibyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes >	units::kibibytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes >	units::KiB
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes >	units::gibibyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes >	units::gibibytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes >	units::GiB
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes > gibi< bytes >	units::pebibyte
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes > gibi< bytes >	units::pebibytes
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes > tera< bytes > kibi< bytes > gibi< bytes >	units::PiB
	units::femtobit
	units::femtobits
	units::fb
femto< bits >	units::nanobit
femto< bits >	units::nanobits
femto< bits >	units::nb
femto< bits > nano< bits >	units::millibit
femto< bits > nano< bits >	units::millibits
femto< bits > nano< bits >	units::mb
femto< bits > nano< bits > milli< bits >	units::decibit
femto< bits > nano< bits > milli< bits >	units::decibits
femto< bits > nano< bits > milli< bits >	units::db
femto< bits > nano< bits > milli< bits > deci< bits >	units::hectobit
femto< bits > nano< bits > milli< bits > deci< bits >	units::hectobits
femto< bits > nano< bits > milli< bits > deci< bits >	units::hb
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits >	units::megabit
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits >	units::megabits
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits >	units::Mb
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits >	units::terabit
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits >	units::terabits
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits >	units::Tb
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits >	units::kibibit
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits >	units::kibibits
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits >	units::Kib
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits >	units::gibibit
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits >	units::gibibits
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits >	units::Gib
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits > gibi< bits >	units::pebibit
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits > gibi< bits >	units::pebibits
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits > tera< bits > kibi< bits > gibi< bits >	units::Pib
	units::femtobytes_per_second
	units::fBps
femto< bytes_per_second >	units::nanobytes_per_second
femto< bytes_per_second >	units::nBps
femto< bytes_per_second > nano< bytes_per_second >	units::millibytes_per_second
femto< bytes_per_second > nano< bytes_per_second >	units::mBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second >	units::decibytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second >	units::dBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second >	units::hectobytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second >	units::hBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second >	units::megabytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second >	units::MBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second >	units::terabytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second >	units::TBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second >	units::kibibytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second >	units::KiBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second >	units::gibibytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second >	units::GiBps
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second > gibi< bytes_per_second >	units::pebibytes_per_second
femto< bytes_per_second > nano< bytes_per_second > milli< bytes_per_second > deci< bytes_per_second > hecto< bytes_per_second > mega< bytes_per_second > tera< bytes_per_second > kibi< bytes_per_second > gibi< bytes_per_second >	units::PiBps
	units::femtobits_per_second
	units::fbps
femto< bits_per_second >	units::nanobits_per_second
femto< bits_per_second >	units::nbps
femto< bits_per_second > nano< bits_per_second >	units::millibits_per_second
femto< bits_per_second > nano< bits_per_second >	units::mbps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second >	units::decibits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second >	units::dbps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second >	units::hectobits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second >	units::hbps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second >	units::megabits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second >	units::Mbps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second >	units::terabits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second >	units::Tbps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second >	units::kibibits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second >	units::Kibps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second >	units::gibibits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second >	units::Gibps
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second > gibi< bits_per_second >	units::pebibits_per_second
femto< bits_per_second > nano< bits_per_second > milli< bits_per_second > deci< bits_per_second > hecto< bits_per_second > mega< bits_per_second > tera< bits_per_second > kibi< bits_per_second > gibi< bits_per_second >	units::Pibps

Unit Containers
using	units::constants::PI = unit<std::ratio<1>, dimensionless::scalar, std::ratio<1>>
static constexpr const unit_t< PI >	units::constants::pi (1)
	Ratio of a circle's circumference to its diameter.
static constexpr const velocity::meters_per_second_t	units::constants::c (299792458.0)
	Speed of light in vacuum.
static constexpr const unit_t< compound_unit< cubed< length::meters >, inverse< mass::kilogram >, inverse< squared< time::seconds > > > >	units::constants::G (6.67408e-11)
	Newtonian constant of gravitation.
static constexpr const unit_t< compound_unit< energy::joule, time::seconds > >	units::constants::h (6.626070040e-34)
	Planck constant.
static constexpr const unit_t< compound_unit< force::newtons, inverse< squared< current::ampere > > > >	units::constants::mu0 (pi *4.0e-7 *force::newton_t(1)/units::math::cpow< 2 >(current::ampere_t(1)))
	vacuum permeability.
static constexpr const unit_t< compound_unit< capacitance::farad, inverse< length::meter > > >	units::constants::epsilon0 (1.0/(mu0 *math::cpow< 2 >(c)))
	vacuum permitivity.
static constexpr const impedance::ohm_t	units::constants::Z0 (mu0 *c)
	characteristic impedance of vacuum.
static constexpr const unit_t< compound_unit< force::newtons, area::square_meter, inverse< squared< charge::coulomb > > > >	units::constants::k_e (1.0/(4 *pi *epsilon0))
	Coulomb's constant.
static constexpr const charge::coulomb_t	units::constants::e (1.6021766208e-19)
	elementary charge.
static constexpr const mass::kilogram_t	units::constants::m_e (9.10938356e-31)
	electron mass.
static constexpr const mass::kilogram_t	units::constants::m_p (1.672621898e-27)
	proton mass.
static constexpr const unit_t< compound_unit< energy::joules, inverse< magnetic_field_strength::tesla > > >	units::constants::mu_B (e *h/(4 *pi *m_e))
	Bohr magneton.
static constexpr const unit_t< inverse< substance::mol > >	units::constants::N_A (6.022140857e23)
	Avagadro's Number.
static constexpr const unit_t< compound_unit< energy::joules, inverse< temperature::kelvin >, inverse< substance::moles > > >	units::constants::R (8.3144598)
	Gas constant.
static constexpr const unit_t< compound_unit< energy::joules, inverse< temperature::kelvin > > >	units::constants::k_B (R/N_A)
	Boltzmann constant.
static constexpr const unit_t< compound_unit< charge::coulomb, inverse< substance::mol > > >	units::constants::F (N_A *e)
	Faraday constant.
static constexpr const unit_t< compound_unit< power::watts, inverse< area::square_meters >, inverse< squared< squared< temperature::kelvin > > > > >	units::constants::sigma ((2 *math::cpow< 5 >(pi) *math::cpow< 4 >(R))/(15 *math::cpow< 3 >(h) *math::cpow< 2 >(c) *math::cpow< 4 >(N_A)))
	Stefan-Boltzmann constant.

Detailed Description

Complete implementation of units - a compile-time, header-only, unit conversion library built on c++14 with no dependencies.

Macro Definition Documentation

UNIT_ADD

#define UNIT_ADD	(		namespaceName,
			nameSingular,
			namePlural,
			abbreviation,
			... )

Value:

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)

Macro for generating the boiler-plate code needed for a new unit.

The macro generates singular, plural, and abbreviated forms of the unit definition (e.g. meter, meters, and m), as well as the appropriately named unit container (e.g. meter_t). A literal suffix is created using the abbreviation (e.g. 10.0_m). It also defines a class-specific cout function which prints both the value and abbreviation of the unit when invoked.

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'meter'
namePlural	- plural version of the unit name, e.g. 'meters'
abbreviation	- abbreviated unit name, e.g. 'm'
definition	- the variadic parameter is used for the definition of the unit (e.g. unit<std::ratio<1>, units::category::length_unit>)

Note

a variadic template is used for the definition to allow templates with commas to be easily expanded. All the variadic 'arguments' should together comprise the unit definition.

UNIT_ADD_CATEGORY_TRAIT

#define UNIT_ADD_CATEGORY_TRAIT

(

unitCategory

)

Value:

UNIT_ADD_CATEGORY_TRAIT_DETAIL(unitCategory)\\\\\
UNIT_ADD_IS_UNIT_CATEGORY_TRAIT(unitCategory)

Macro to create the is_category_unit type trait.

This trait allows users to test whether a given type matches an intended category. This macro comprises all the boiler-plate code necessary to do so.

Parameters

unitCategory

The name of the category of unit, e.g. length or mass.

UNIT_ADD_CATEGORY_TRAIT_DETAIL

#define UNIT_ADD_CATEGORY_TRAIT_DETAIL

(

unitCategory

)

Value:

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

UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION

#define UNIT_ADD_CUSTOM_TYPE_UNIT_DEFINITION	(		namespaceName,
			nameSingular,
			underlyingType )

Value:

namespace namespaceName\
{\  typedef unit_t<nameSingular,underlyingType> nameSingular ## _t; \
}

Macro for generating the boiler-plate code for a unit_t type definition with a non-default underlying type.

The macro generates the definition of the unit container types, e.g. meter_t

Parameters

namespaceName	namespace in which the new units will be encapsulated.
nameSingular	singular version of the unit name, e.g. 'meter'
underlyingType	the underlying type

UNIT_ADD_DECIBEL

#define UNIT_ADD_DECIBEL	(		namespaceName,
			nameSingular,
			abbreviation )

Value:

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)

Macro to create decibel container and literals for an existing unit type.

This macro generates the decibel unit container, cout overload, and literal definitions.

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the base unit name, e.g. 'watt'
abbreviation	- abbreviated decibel unit name, e.g. 'dBW'

UNIT_ADD_IO

#define UNIT_ADD_IO	(		namespaceName,
			nameSingular,
			abbrev )

Value:

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);\
    }\
}

Macro for generating the boiler-plate code needed for I/O for a new unit.

The macro generates the code to insert units into an ostream. It prints both the value and abbreviation of the unit when invoked.

Parameters

namespaceName	namespace in which the new units will be encapsulated.
nameSingular	singular version of the unit name, e.g. 'meter'
abbrev	- abbreviated unit name, e.g. 'm'

Note

When UNIT_LIB_DISABLE_IOSTREAM is defined, the macro does not generate any code

UNIT_ADD_IS_UNIT_CATEGORY_TRAIT

#define UNIT_ADD_IS_UNIT_CATEGORY_TRAIT

(

unitCategory

)

Value:

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

UNIT_ADD_LITERALS

#define UNIT_ADD_LITERALS	(		namespaceName,
			nameSingular,
			abbreviation )

Value:

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));\
    }\
}

Macro for generating user-defined literals for units.

The macro generates user-defined literals for units. A literal suffix is created using the abbreviation (e.g. 10.0_m).

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'meter'
abbreviation	- abbreviated unit name, e.g. 'm'

Note

When UNIT_HAS_LITERAL_SUPPORT is not defined, the macro does not generate any code

UNIT_ADD_NAME

#define UNIT_ADD_NAME	(		namespaceName,
			nameSingular,
			namePlural,
			abbrev )

Value:

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

Macro for generating constexpr names/abbreviations for units.

The macro generates names for units. E.g. name() of 1_m would be "meter", and abbreviation would be "m".

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'meter'
namePlural	plural version of the unit name, e.g. 'meters'
abbreviation	- abbreviated unit name, e.g. 'm'

UNIT_ADD_UNIT_DEFINITION

#define UNIT_ADD_UNIT_DEFINITION	(		namespaceName,
			nameSingular )

Value:

namespace namespaceName\
{\  typedef unit_t<nameSingular> nameSingular ## _t; \
}

Macro for generating the boiler-plate code for the unit_t type definition.

The macro generates the definition of the unit container types, e.g. meter_t

Parameters

namespaceName	namespace in which the new units will be encapsulated.
nameSingular	singular version of the unit name, e.g. 'meter'

UNIT_ADD_UNIT_TAGS

#define UNIT_ADD_UNIT_TAGS	(		namespaceName,
			nameSingular,
			namePlural,
			abbreviation,
			... )

Value:

namespace namespaceName\
{\  typedef __VA_ARGS__ namePlural; \  typedef namePlural nameSingular; \  typedef namePlural abbreviation; \
}

Helper macro for generating the boiler-plate code generating the tags of a new unit.

The macro generates singular, plural, and abbreviated forms of the unit definition (e.g. meter, meters, and m), as aliases for the unit tag.

Parameters

namespaceName	namespace in which the new units will be encapsulated.
nameSingular	singular version of the unit name, e.g. 'meter'
namePlural	- plural version of the unit name, e.g. 'meters'
abbreviation	- abbreviated unit name, e.g. 'm'
definition	- the variadic parameter is used for the definition of the unit (e.g. unit<std::ratio<1>, units::category::length_unit>)

Note

a variadic template is used for the definition to allow templates with commas to be easily expanded. All the variadic 'arguments' should together comprise the unit definition.

UNIT_ADD_WITH_CUSTOM_TYPE

#define UNIT_ADD_WITH_CUSTOM_TYPE	(		namespaceName,
			nameSingular,
			namePlural,
			abbreviation,
			underlyingType,
			... )

Value:

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)

Macro for generating the boiler-plate code needed for a new unit with a non-default underlying type.

The macro generates singular, plural, and abbreviated forms of the unit definition (e.g. meter, meters, and m), as well as the appropriately named unit container (e.g. meter_t). A literal suffix is created using the abbreviation (e.g. 10.0_m). It also defines a class-specific cout function which prints both the value and abbreviation of the unit when invoked.

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'meter'
namePlural	- plural version of the unit name, e.g. 'meters'
abbreviation	- abbreviated unit name, e.g. 'm'
underlyingType	- the underlying type, e.g. 'int' or 'float'
definition	- the variadic parameter is used for the definition of the unit (e.g. unit<std::ratio<1>, units::category::length_unit>)

Note

a variadic template is used for the definition to allow templates with commas to be easily expanded. All the variadic 'arguments' should together comprise the unit definition.

UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES

#define UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES	(		namespaceName,
			nameSingular,
			namePlural,
			abbreviation,
			... )

Value:

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>)

Macro for generating the boiler-plate code needed for a new unit, including its metric prefixes from femto to peta, and binary prefixes from kibi to exbi.

See UNIT_ADD. In addition to generating the unit definition and containers '(e.g. bytes and 'byte_t', it also creates corresponding units with metric suffixes such as millimeters, and millimeter_t), as well as the literal suffixes (e.g. 10.0_B).

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'byte'
namePlural	- plural version of the unit name, e.g. 'bytes'
abbreviation	- abbreviated unit name, e.g. 'B'
definition	- the variadic parameter is used for the definition of the unit (e.g. unit<std::ratio<1>, units::category::data_unit>)

Note

a variadic template is used for the definition to allow templates with commas to be easily expanded. All the variadic 'arguments' should together comprise the unit definition.

UNIT_ADD_WITH_METRIC_PREFIXES

#define UNIT_ADD_WITH_METRIC_PREFIXES	(		namespaceName,
			nameSingular,
			namePlural,
			abbreviation,
			... )

Value:

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>)\

Macro for generating the boiler-plate code needed for a new unit, including its metric prefixes from femto to peta.

See UNIT_ADD. In addition to generating the unit definition and containers '(e.g. meters and 'meter_t', it also creates corresponding units with metric suffixes such as millimeters, and millimeter_t), as well as the literal suffixes (e.g. 10.0_mm).

Parameters

namespaceName	namespace in which the new units will be encapsulated. All literal values are placed in the units::literals namespace.
nameSingular	singular version of the unit name, e.g. 'meter'
namePlural	- plural version of the unit name, e.g. 'meters'
abbreviation	- abbreviated unit name, e.g. 'm'
definition	- the variadic parameter is used for the definition of the unit (e.g. unit<std::ratio<1>, units::category::length_unit>)

Note

a variadic template is used for the definition to allow templates with commas to be easily expanded. All the variadic 'arguments' should together comprise the unit definition.