units Namespace Reference

Unit Conversion Library namespace. More...

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

Classes
struct	base_unit
	Class representing SI base unit types. More...
struct	unit
	Type representing an arbitrary unit. More...
class	unit_t
	Container for values which represent quantities of a given unit. More...
struct	decibel_scale
	unit_t scale for representing decibel values. More...
struct	linear_scale
	unit_t scale which is linear More...
struct	unit_value_t
	Stores a rational unit value as a compile-time constant. More...
struct	unit_value_add
	adds two unit_value_t types at compile-time More...
struct	unit_value_subtract
	subtracts two unit_value_t types at compile-time More...
struct	unit_value_multiply
	multiplies two unit_value_t types at compile-time More...
struct	unit_value_divide
	divides two unit_value_t types at compile-time More...
struct	unit_value_power
	raises unit_value_to a power at compile-time More...
struct	unit_value_sqrt
	calculates square root of unit_value_t at compile-time More...

Typedefs
template<class U>
using	inverse = typename units::detail::inverse_impl<U>::type
	represents the inverse unit type of class U.
template<class U>
using	squared = typename units::detail::squared_impl<U>::type
	represents the unit type of class U squared
template<class U>
using	cubed = typename units::detail::cubed_impl<U>::type
	represents the type of class U cubed.
template<typename Ratio, std::intmax_t Eps = 10000000000>
using	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	square_root = typename units::detail::sqrt_impl<U, Eps>::type
	represents the square root of type class U.
template<class U, class... Us>
using	compound_unit = typename units::detail::compound_impl<U, Us...>::type
	Represents a unit type made up from other units.
template<class U>
using	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	exbi = typename units::detail::prefix<std::ratio<1152921504606846976>, U>::type
	Represents the type of class U with the binary 'exbi' prefix appended.

Functions
template<typename T>
constexpr const char *	name (const T &)
template<typename T>
constexpr const char *	name_plural (const T &)
template<typename T>
constexpr const char *	abbreviation (const T &)
template<class UnitFrom, class UnitTo, typename T = double>
static constexpr T	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	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 &	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 > &	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 > &	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 > &	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 > &	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 >	operator+ (const unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale > &	operator++ (unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	operator++ (unit_t< Units, T, NonLinearScale > &u, int) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	operator- (const unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale > &	operator-- (unit_t< Units, T, NonLinearScale > &u) noexcept
template<class Units, typename T, template< typename > class NonLinearScale>
constexpr unit_t< Units, T, NonLinearScale >	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	operator< (const Units &lhs, const double rhs) noexcept
template<class UnitTypeLhs, class UnitTypeRhs, std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr auto	operator+ (const UnitTypeLhs &lhs, const UnitTypeRhs &rhs) noexcept -> unit_t< compound_unit< squared< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type > >, typename units::traits::unit_t_traits< UnitTypeLhs >::underlying_type, decibel_scale >
	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	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	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	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	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	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 *	name (const length::meter_t &)
template<>
constexpr const char *	abbreviation (const length::meter_t &)
template<>
constexpr const char *	name_plural (const length::meter_t &)
	UNIT_ADD_LITERALS (length, meter, m) UNIT_ADD(length
femto< meters >	UNIT_ADD (length, picometer, picometers, pm, pico< meters >) UNIT_ADD(length
femto< meters > nano< meters >	UNIT_ADD (length, micrometer, micrometers, um, micro< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters >	UNIT_ADD (length, centimeter, centimeters, cm, centi< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters >	UNIT_ADD (length, decameter, decameters, dam, deca< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters >	UNIT_ADD (length, kilometer, kilometers, km, kilo< meters >) UNIT_ADD(length
femto< meters > nano< meters > milli< meters > deci< meters > hecto< meters > mega< meters >	UNIT_ADD (length, gigameter, gigameters, Gm, giga< meters >) UNIT_ADD(length
template<>
constexpr const char *	name (const length::foot_t &)
template<>
constexpr const char *	abbreviation (const length::foot_t &)
template<>
constexpr const char *	name_plural (const length::foot_t &)
template<>
constexpr const char *	name (const length::inch_t &)
template<>
constexpr const char *	abbreviation (const length::inch_t &)
template<>
constexpr const char *	name_plural (const length::inch_t &)
template<>
constexpr const char *	name (const length::mil_t &)
template<>
constexpr const char *	abbreviation (const length::mil_t &)
template<>
constexpr const char *	name_plural (const length::mil_t &)
template<>
constexpr const char *	name (const length::mile_t &)
template<>
constexpr const char *	abbreviation (const length::mile_t &)
template<>
constexpr const char *	name_plural (const length::mile_t &)
template<>
constexpr const char *	name (const length::nauticalMile_t &)
template<>
constexpr const char *	abbreviation (const length::nauticalMile_t &)
template<>
constexpr const char *	name_plural (const length::nauticalMile_t &)
template<>
constexpr const char *	name (const length::astronicalUnit_t &)
template<>
constexpr const char *	abbreviation (const length::astronicalUnit_t &)
template<>
constexpr const char *	name_plural (const length::astronicalUnit_t &)
template<>
constexpr const char *	name (const length::lightyear_t &)
template<>
constexpr const char *	abbreviation (const length::lightyear_t &)
template<>
constexpr const char *	name_plural (const length::lightyear_t &)
template<>
constexpr const char *	name (const length::parsec_t &)
template<>
constexpr const char *	abbreviation (const length::parsec_t &)
template<>
constexpr const char *	name_plural (const length::parsec_t &)
template<>
constexpr const char *	name (const length::angstrom_t &)
template<>
constexpr const char *	abbreviation (const length::angstrom_t &)
template<>
constexpr const char *	name_plural (const length::angstrom_t &)
template<>
constexpr const char *	name (const length::cubit_t &)
template<>
constexpr const char *	abbreviation (const length::cubit_t &)
template<>
constexpr const char *	name_plural (const length::cubit_t &)
template<>
constexpr const char *	name (const length::fathom_t &)
template<>
constexpr const char *	abbreviation (const length::fathom_t &)
template<>
constexpr const char *	name_plural (const length::fathom_t &)
template<>
constexpr const char *	name (const length::chain_t &)
template<>
constexpr const char *	abbreviation (const length::chain_t &)
template<>
constexpr const char *	name_plural (const length::chain_t &)
template<>
constexpr const char *	name (const length::furlong_t &)
template<>
constexpr const char *	abbreviation (const length::furlong_t &)
template<>
constexpr const char *	name_plural (const length::furlong_t &)
template<>
constexpr const char *	name (const length::hand_t &)
template<>
constexpr const char *	abbreviation (const length::hand_t &)
template<>
constexpr const char *	name_plural (const length::hand_t &)
template<>
constexpr const char *	name (const length::league_t &)
template<>
constexpr const char *	abbreviation (const length::league_t &)
template<>
constexpr const char *	name_plural (const length::league_t &)
template<>
constexpr const char *	name (const length::nauticalLeague_t &)
template<>
constexpr const char *	abbreviation (const length::nauticalLeague_t &)
template<>
constexpr const char *	name_plural (const length::nauticalLeague_t &)
template<>
constexpr const char *	name (const length::yard_t &)
template<>
constexpr const char *	abbreviation (const length::yard_t &)
template<>
constexpr const char *	name_plural (const length::yard_t &)
	UNIT_ADD_LITERALS (length, yard, yd) namespace traits
template<>
constexpr const char *	name (const mass::gram_t &)
template<>
constexpr const char *	abbreviation (const mass::gram_t &)
template<>
constexpr const char *	name_plural (const mass::gram_t &)
	UNIT_ADD_LITERALS (mass, gram, g) UNIT_ADD(mass
femto< grams >	UNIT_ADD (mass, picogram, picograms, pg, pico< grams >) UNIT_ADD(mass
femto< grams > nano< grams >	UNIT_ADD (mass, microgram, micrograms, ug, micro< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams >	UNIT_ADD (mass, centigram, centigrams, cg, centi< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams >	UNIT_ADD (mass, decagram, decagrams, dag, deca< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams >	UNIT_ADD (mass, kilogram, kilograms, kg, kilo< grams >) UNIT_ADD(mass
femto< grams > nano< grams > milli< grams > deci< grams > hecto< grams > mega< grams >	UNIT_ADD (mass, gigagram, gigagrams, Gg, giga< grams >) UNIT_ADD(mass
template<>
constexpr const char *	name (const mass::metric_ton_t &)
template<>
constexpr const char *	abbreviation (const mass::metric_ton_t &)
template<>
constexpr const char *	name_plural (const mass::metric_ton_t &)
template<>
constexpr const char *	name (const mass::pound_t &)
template<>
constexpr const char *	abbreviation (const mass::pound_t &)
template<>
constexpr const char *	name_plural (const mass::pound_t &)
template<>
constexpr const char *	name (const mass::long_ton_t &)
template<>
constexpr const char *	abbreviation (const mass::long_ton_t &)
template<>
constexpr const char *	name_plural (const mass::long_ton_t &)
template<>
constexpr const char *	name (const mass::short_ton_t &)
template<>
constexpr const char *	abbreviation (const mass::short_ton_t &)
template<>
constexpr const char *	name_plural (const mass::short_ton_t &)
template<>
constexpr const char *	name (const mass::stone_t &)
template<>
constexpr const char *	abbreviation (const mass::stone_t &)
template<>
constexpr const char *	name_plural (const mass::stone_t &)
template<>
constexpr const char *	name (const mass::ounce_t &)
template<>
constexpr const char *	abbreviation (const mass::ounce_t &)
template<>
constexpr const char *	name_plural (const mass::ounce_t &)
template<>
constexpr const char *	name (const mass::carat_t &)
template<>
constexpr const char *	abbreviation (const mass::carat_t &)
template<>
constexpr const char *	name_plural (const mass::carat_t &)
template<>
constexpr const char *	name (const mass::slug_t &)
template<>
constexpr const char *	abbreviation (const mass::slug_t &)
template<>
constexpr const char *	name_plural (const mass::slug_t &)
	UNIT_ADD_LITERALS (mass, slug, slug) namespace traits
template<>
constexpr const char *	name (const time::second_t &)
template<>
constexpr const char *	abbreviation (const time::second_t &)
template<>
constexpr const char *	name_plural (const time::second_t &)
	UNIT_ADD_LITERALS (time, second, s) UNIT_ADD(time
femto< seconds >	UNIT_ADD (time, picosecond, picoseconds, ps, pico< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds >	UNIT_ADD (time, microsecond, microseconds, us, micro< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds >	UNIT_ADD (time, centisecond, centiseconds, cs, centi< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds >	UNIT_ADD (time, decasecond, decaseconds, das, deca< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds >	UNIT_ADD (time, kilosecond, kiloseconds, ks, kilo< seconds >) UNIT_ADD(time
femto< seconds > nano< seconds > milli< seconds > deci< seconds > hecto< seconds > mega< seconds >	UNIT_ADD (time, gigasecond, gigaseconds, Gs, giga< seconds >) UNIT_ADD(time
template<>
constexpr const char *	name (const time::minute_t &)
template<>
constexpr const char *	abbreviation (const time::minute_t &)
template<>
constexpr const char *	name_plural (const time::minute_t &)
template<>
constexpr const char *	name (const time::hour_t &)
template<>
constexpr const char *	abbreviation (const time::hour_t &)
template<>
constexpr const char *	name_plural (const time::hour_t &)
template<>
constexpr const char *	name (const time::day_t &)
template<>
constexpr const char *	abbreviation (const time::day_t &)
template<>
constexpr const char *	name_plural (const time::day_t &)
template<>
constexpr const char *	name (const time::week_t &)
template<>
constexpr const char *	abbreviation (const time::week_t &)
template<>
constexpr const char *	name_plural (const time::week_t &)
template<>
constexpr const char *	name (const time::year_t &)
template<>
constexpr const char *	abbreviation (const time::year_t &)
template<>
constexpr const char *	name_plural (const time::year_t &)
template<>
constexpr const char *	name (const time::julian_year_t &)
template<>
constexpr const char *	abbreviation (const time::julian_year_t &)
template<>
constexpr const char *	name_plural (const time::julian_year_t &)
template<>
constexpr const char *	name (const time::gregorian_year_t &)
template<>
constexpr const char *	abbreviation (const time::gregorian_year_t &)
template<>
constexpr const char *	name_plural (const time::gregorian_year_t &)
	UNIT_ADD_LITERALS (time, gregorian_year, a_g) namespace traits
template<>
constexpr const char *	name (const angle::radian_t &)
template<>
constexpr const char *	abbreviation (const angle::radian_t &)
template<>
constexpr const char *	name_plural (const angle::radian_t &)
	UNIT_ADD_LITERALS (angle, radian, rad) UNIT_ADD(angle
femto< radians >	UNIT_ADD (angle, picoradian, picoradians, prad, pico< radians >) UNIT_ADD(angle
femto< radians > nano< radians >	UNIT_ADD (angle, microradian, microradians, urad, micro< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians >	UNIT_ADD (angle, centiradian, centiradians, crad, centi< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians >	UNIT_ADD (angle, decaradian, decaradians, darad, deca< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians >	UNIT_ADD (angle, kiloradian, kiloradians, krad, kilo< radians >) UNIT_ADD(angle
femto< radians > nano< radians > milli< radians > deci< radians > hecto< radians > mega< radians >	UNIT_ADD (angle, gigaradian, gigaradians, Grad, giga< radians >) UNIT_ADD(angle
template<>
constexpr const char *	name (const angle::degree_t &)
template<>
constexpr const char *	abbreviation (const angle::degree_t &)
template<>
constexpr const char *	name_plural (const angle::degree_t &)
template<>
constexpr const char *	name (const angle::arcminute_t &)
template<>
constexpr const char *	abbreviation (const angle::arcminute_t &)
template<>
constexpr const char *	name_plural (const angle::arcminute_t &)
template<>
constexpr const char *	name (const angle::arcsecond_t &)
template<>
constexpr const char *	abbreviation (const angle::arcsecond_t &)
template<>
constexpr const char *	name_plural (const angle::arcsecond_t &)
template<>
constexpr const char *	name (const angle::milliarcsecond_t &)
template<>
constexpr const char *	abbreviation (const angle::milliarcsecond_t &)
template<>
constexpr const char *	name_plural (const angle::milliarcsecond_t &)
template<>
constexpr const char *	name (const angle::turn_t &)
template<>
constexpr const char *	abbreviation (const angle::turn_t &)
template<>
constexpr const char *	name_plural (const angle::turn_t &)
template<>
constexpr const char *	name (const angle::gradian_t &)
template<>
constexpr const char *	abbreviation (const angle::gradian_t &)
template<>
constexpr const char *	name_plural (const angle::gradian_t &)
	UNIT_ADD_LITERALS (angle, gradian, gon) namespace traits
template<>
constexpr const char *	name (const current::ampere_t &)
template<>
constexpr const char *	abbreviation (const current::ampere_t &)
template<>
constexpr const char *	name_plural (const current::ampere_t &)
	UNIT_ADD_LITERALS (current, ampere, A) UNIT_ADD(current
femto< amperes >	UNIT_ADD (current, picoampere, picoamperes, pA, pico< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes >	UNIT_ADD (current, microampere, microamperes, uA, micro< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes >	UNIT_ADD (current, centiampere, centiamperes, cA, centi< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes >	UNIT_ADD (current, decaampere, decaamperes, daA, deca< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes >	UNIT_ADD (current, kiloampere, kiloamperes, kA, kilo< amperes >) UNIT_ADD(current
femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes >	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 >	UNIT_ADD (current, petaampere, petaamperes, PA, peta< amperes >) namespace traits
template<>
constexpr const char *	name (const temperature::kelvin_t &)
template<>
constexpr const char *	abbreviation (const temperature::kelvin_t &)
template<>
constexpr const char *	name_plural (const temperature::kelvin_t &)
template<>
constexpr const char *	name (const temperature::celsius_t &)
template<>
constexpr const char *	abbreviation (const temperature::celsius_t &)
template<>
constexpr const char *	name_plural (const temperature::celsius_t &)
template<>
constexpr const char *	name (const temperature::fahrenheit_t &)
template<>
constexpr const char *	abbreviation (const temperature::fahrenheit_t &)
template<>
constexpr const char *	name_plural (const temperature::fahrenheit_t &)
template<>
constexpr const char *	name (const temperature::reaumur_t &)
template<>
constexpr const char *	abbreviation (const temperature::reaumur_t &)
template<>
constexpr const char *	name_plural (const temperature::reaumur_t &)
template<>
constexpr const char *	name (const temperature::rankine_t &)
template<>
constexpr const char *	abbreviation (const temperature::rankine_t &)
template<>
constexpr const char *	name_plural (const temperature::rankine_t &)
	UNIT_ADD_LITERALS (temperature, rankine, Ra) namespace traits
template<>
constexpr const char *	name (const substance::mole_t &)
template<>
constexpr const char *	abbreviation (const substance::mole_t &)
template<>
constexpr const char *	name_plural (const substance::mole_t &)
	UNIT_ADD_LITERALS (substance, mole, mol) namespace traits
template<>
constexpr const char *	name (const luminous_intensity::candela_t &)
template<>
constexpr const char *	abbreviation (const luminous_intensity::candela_t &)
template<>
constexpr const char *	name_plural (const luminous_intensity::candela_t &)
	UNIT_ADD_LITERALS (luminous_intensity, candela, cd) UNIT_ADD(luminous_intensity
femto< candelas >	UNIT_ADD (luminous_intensity, picocandela, picocandelas, pcd, pico< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas >	UNIT_ADD (luminous_intensity, microcandela, microcandelas, ucd, micro< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas >	UNIT_ADD (luminous_intensity, centicandela, centicandelas, ccd, centi< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas >	UNIT_ADD (luminous_intensity, decacandela, decacandelas, dacd, deca< candelas >) UNIT_ADD(luminous_intensity
femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas >	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 >	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 >	UNIT_ADD (luminous_intensity, petacandela, petacandelas, Pcd, peta< candelas >) namespace traits
template<>
constexpr const char *	name (const solid_angle::steradian_t &)
template<>
constexpr const char *	abbreviation (const solid_angle::steradian_t &)
template<>
constexpr const char *	name_plural (const solid_angle::steradian_t &)
	UNIT_ADD_LITERALS (solid_angle, steradian, sr) UNIT_ADD(solid_angle
femto< steradians >	UNIT_ADD (solid_angle, picosteradian, picosteradians, psr, pico< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians >	UNIT_ADD (solid_angle, microsteradian, microsteradians, usr, micro< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians >	UNIT_ADD (solid_angle, centisteradian, centisteradians, csr, centi< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians > deci< steradians >	UNIT_ADD (solid_angle, decasteradian, decasteradians, dasr, deca< steradians >) UNIT_ADD(solid_angle
femto< steradians > nano< steradians > milli< steradians > deci< steradians > hecto< steradians >	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 >	UNIT_ADD (solid_angle, gigasteradian, gigasteradians, Gsr, giga< steradians >) UNIT_ADD(solid_angle
template<>
constexpr const char *	name (const solid_angle::degree_squared_t &)
template<>
constexpr const char *	abbreviation (const solid_angle::degree_squared_t &)
template<>
constexpr const char *	name_plural (const solid_angle::degree_squared_t &)
template<>
constexpr const char *	name (const solid_angle::spat_t &)
template<>
constexpr const char *	abbreviation (const solid_angle::spat_t &)
template<>
constexpr const char *	name_plural (const solid_angle::spat_t &)
	UNIT_ADD_LITERALS (solid_angle, spat, sp) namespace traits
template<>
constexpr const char *	name (const frequency::hertz_t &)
template<>
constexpr const char *	abbreviation (const frequency::hertz_t &)
template<>
constexpr const char *	name_plural (const frequency::hertz_t &)
	UNIT_ADD_LITERALS (frequency, hertz, Hz) UNIT_ADD(frequency
femto< hertz >	UNIT_ADD (frequency, picohertz, picohertz, pHz, pico< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz >	UNIT_ADD (frequency, microhertz, microhertz, uHz, micro< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz >	UNIT_ADD (frequency, centihertz, centihertz, cHz, centi< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz >	UNIT_ADD (frequency, decahertz, decahertz, daHz, deca< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz >	UNIT_ADD (frequency, kilohertz, kilohertz, kHz, kilo< hertz >) UNIT_ADD(frequency
femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz >	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 >	UNIT_ADD (frequency, petahertz, petahertz, PHz, peta< hertz >) namespace traits
template<>
constexpr const char *	name (const velocity::meters_per_second_t &)
template<>
constexpr const char *	abbreviation (const velocity::meters_per_second_t &)
template<>
constexpr const char *	name_plural (const velocity::meters_per_second_t &)
template<>
constexpr const char *	name (const velocity::feet_per_second_t &)
template<>
constexpr const char *	abbreviation (const velocity::feet_per_second_t &)
template<>
constexpr const char *	name_plural (const velocity::feet_per_second_t &)
template<>
constexpr const char *	name (const velocity::miles_per_hour_t &)
template<>
constexpr const char *	abbreviation (const velocity::miles_per_hour_t &)
template<>
constexpr const char *	name_plural (const velocity::miles_per_hour_t &)
template<>
constexpr const char *	name (const velocity::kilometers_per_hour_t &)
template<>
constexpr const char *	abbreviation (const velocity::kilometers_per_hour_t &)
template<>
constexpr const char *	name_plural (const velocity::kilometers_per_hour_t &)
template<>
constexpr const char *	name (const velocity::knot_t &)
template<>
constexpr const char *	abbreviation (const velocity::knot_t &)
template<>
constexpr const char *	name_plural (const velocity::knot_t &)
	UNIT_ADD_LITERALS (velocity, knot, kts) namespace traits
template<>
constexpr const char *	name (const angular_velocity::radians_per_second_t &)
template<>
constexpr const char *	abbreviation (const angular_velocity::radians_per_second_t &)
template<>
constexpr const char *	name_plural (const angular_velocity::radians_per_second_t &)
template<>
constexpr const char *	name (const angular_velocity::degrees_per_second_t &)
template<>
constexpr const char *	abbreviation (const angular_velocity::degrees_per_second_t &)
template<>
constexpr const char *	name_plural (const angular_velocity::degrees_per_second_t &)
template<>
constexpr const char *	name (const angular_velocity::revolutions_per_minute_t &)
template<>
constexpr const char *	abbreviation (const angular_velocity::revolutions_per_minute_t &)
template<>
constexpr const char *	name_plural (const angular_velocity::revolutions_per_minute_t &)
template<>
constexpr const char *	name (const angular_velocity::revolutions_per_second_t &)
template<>
constexpr const char *	abbreviation (const angular_velocity::revolutions_per_second_t &)
template<>
constexpr const char *	name_plural (const angular_velocity::revolutions_per_second_t &)
template<>
constexpr const char *	name (const angular_velocity::milliarcseconds_per_year_t &)
template<>
constexpr const char *	abbreviation (const angular_velocity::milliarcseconds_per_year_t &)
template<>
constexpr const char *	name_plural (const angular_velocity::milliarcseconds_per_year_t &)
	UNIT_ADD_LITERALS (angular_velocity, milliarcseconds_per_year, mas_per_yr) namespace traits
template<>
constexpr const char *	name (const acceleration::meters_per_second_squared_t &)
template<>
constexpr const char *	abbreviation (const acceleration::meters_per_second_squared_t &)
template<>
constexpr const char *	name_plural (const acceleration::meters_per_second_squared_t &)
template<>
constexpr const char *	name (const acceleration::feet_per_second_squared_t &)
template<>
constexpr const char *	abbreviation (const acceleration::feet_per_second_squared_t &)
template<>
constexpr const char *	name_plural (const acceleration::feet_per_second_squared_t &)
template<>
constexpr const char *	name (const acceleration::standard_gravity_t &)
template<>
constexpr const char *	abbreviation (const acceleration::standard_gravity_t &)
template<>
constexpr const char *	name_plural (const acceleration::standard_gravity_t &)
	UNIT_ADD_LITERALS (acceleration, standard_gravity, SG) namespace traits
template<>
constexpr const char *	name (const jerk::meters_per_second_cubed_t &)
template<>
constexpr const char *	abbreviation (const jerk::meters_per_second_cubed_t &)
template<>
constexpr const char *	name_plural (const jerk::meters_per_second_cubed_t &)
template<>
constexpr const char *	name (const jerk::feet_per_second_cubed_t &)
template<>
constexpr const char *	abbreviation (const jerk::feet_per_second_cubed_t &)
template<>
constexpr const char *	name_plural (const jerk::feet_per_second_cubed_t &)
	UNIT_ADD_LITERALS (jerk, feet_per_second_cubed, fps_cb) namespace traits
template<>
constexpr const char *	name (const force::newton_t &)
template<>
constexpr const char *	abbreviation (const force::newton_t &)
template<>
constexpr const char *	name_plural (const force::newton_t &)
	UNIT_ADD_LITERALS (force, newton, N) UNIT_ADD(force
femto< newtons >	UNIT_ADD (force, piconewton, piconewtons, pN, pico< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons >	UNIT_ADD (force, micronewton, micronewtons, uN, micro< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons >	UNIT_ADD (force, centinewton, centinewtons, cN, centi< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons >	UNIT_ADD (force, decanewton, decanewtons, daN, deca< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons >	UNIT_ADD (force, kilonewton, kilonewtons, kN, kilo< newtons >) UNIT_ADD(force
femto< newtons > nano< newtons > milli< newtons > deci< newtons > hecto< newtons > mega< newtons >	UNIT_ADD (force, giganewton, giganewtons, GN, giga< newtons >) UNIT_ADD(force
template<>
constexpr const char *	name (const force::pound_t &)
template<>
constexpr const char *	abbreviation (const force::pound_t &)
template<>
constexpr const char *	name_plural (const force::pound_t &)
template<>
constexpr const char *	name (const force::dyne_t &)
template<>
constexpr const char *	abbreviation (const force::dyne_t &)
template<>
constexpr const char *	name_plural (const force::dyne_t &)
template<>
constexpr const char *	name (const force::kilopond_t &)
template<>
constexpr const char *	abbreviation (const force::kilopond_t &)
template<>
constexpr const char *	name_plural (const force::kilopond_t &)
template<>
constexpr const char *	name (const force::poundal_t &)
template<>
constexpr const char *	abbreviation (const force::poundal_t &)
template<>
constexpr const char *	name_plural (const force::poundal_t &)
	UNIT_ADD_LITERALS (force, poundal, pdl) namespace traits
template<>
constexpr const char *	name (const pressure::pascal_t &)
template<>
constexpr const char *	abbreviation (const pressure::pascal_t &)
template<>
constexpr const char *	name_plural (const pressure::pascal_t &)
	UNIT_ADD_LITERALS (pressure, pascal, Pa) UNIT_ADD(pressure
femto< pascals >	UNIT_ADD (pressure, picopascal, picopascals, pPa, pico< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals >	UNIT_ADD (pressure, micropascal, micropascals, uPa, micro< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals >	UNIT_ADD (pressure, centipascal, centipascals, cPa, centi< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals >	UNIT_ADD (pressure, decapascal, decapascals, daPa, deca< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals >	UNIT_ADD (pressure, kilopascal, kilopascals, kPa, kilo< pascals >) UNIT_ADD(pressure
femto< pascals > nano< pascals > milli< pascals > deci< pascals > hecto< pascals > mega< pascals >	UNIT_ADD (pressure, gigapascal, gigapascals, GPa, giga< pascals >) UNIT_ADD(pressure
template<>
constexpr const char *	name (const pressure::bar_t &)
template<>
constexpr const char *	abbreviation (const pressure::bar_t &)
template<>
constexpr const char *	name_plural (const pressure::bar_t &)
template<>
constexpr const char *	name (const pressure::mbar_t &)
template<>
constexpr const char *	abbreviation (const pressure::mbar_t &)
template<>
constexpr const char *	name_plural (const pressure::mbar_t &)
template<>
constexpr const char *	name (const pressure::atmosphere_t &)
template<>
constexpr const char *	abbreviation (const pressure::atmosphere_t &)
template<>
constexpr const char *	name_plural (const pressure::atmosphere_t &)
template<>
constexpr const char *	name (const pressure::pounds_per_square_inch_t &)
template<>
constexpr const char *	abbreviation (const pressure::pounds_per_square_inch_t &)
template<>
constexpr const char *	name_plural (const pressure::pounds_per_square_inch_t &)
template<>
constexpr const char *	name (const pressure::torr_t &)
template<>
constexpr const char *	abbreviation (const pressure::torr_t &)
template<>
constexpr const char *	name_plural (const pressure::torr_t &)
template<>
constexpr const char *	name (const pressure::millimeter_of_mercury_t &)
template<>
constexpr const char *	abbreviation (const pressure::millimeter_of_mercury_t &)
template<>
constexpr const char *	name_plural (const pressure::millimeter_of_mercury_t &)
template<>
constexpr const char *	name (const pressure::inch_of_mercury_t &)
template<>
constexpr const char *	abbreviation (const pressure::inch_of_mercury_t &)
template<>
constexpr const char *	name_plural (const pressure::inch_of_mercury_t &)
	UNIT_ADD_LITERALS (pressure, inch_of_mercury, inHg) namespace traits
template<>
constexpr const char *	name (const charge::coulomb_t &)
template<>
constexpr const char *	abbreviation (const charge::coulomb_t &)
template<>
constexpr const char *	name_plural (const charge::coulomb_t &)
	UNIT_ADD_LITERALS (charge, coulomb, C) UNIT_ADD(charge
femto< coulombs >	UNIT_ADD (charge, picocoulomb, picocoulombs, pC, pico< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs >	UNIT_ADD (charge, microcoulomb, microcoulombs, uC, micro< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs >	UNIT_ADD (charge, centicoulomb, centicoulombs, cC, centi< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs >	UNIT_ADD (charge, decacoulomb, decacoulombs, daC, deca< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs >	UNIT_ADD (charge, kilocoulomb, kilocoulombs, kC, kilo< coulombs >) UNIT_ADD(charge
femto< coulombs > nano< coulombs > milli< coulombs > deci< coulombs > hecto< coulombs > mega< coulombs >	UNIT_ADD (charge, gigacoulomb, gigacoulombs, GC, giga< coulombs >) UNIT_ADD(charge
template<>
constexpr const char *	name (const charge::ampere_hour_t &)
template<>
constexpr const char *	abbreviation (const charge::ampere_hour_t &)
template<>
constexpr const char *	name_plural (const charge::ampere_hour_t &)
	UNIT_ADD_LITERALS (charge, ampere_hour, Ah) UNIT_ADD(charge
femto< ampere_hours >	UNIT_ADD (charge, picoampere_hour, picoampere_hours, pAh, pico< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours >	UNIT_ADD (charge, microampere_hour, microampere_hours, uAh, micro< ampere_hours >) UNIT_ADD(charge
femto< ampere_hours > nano< ampere_hours > milli< ampere_hours >	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 >	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 >	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 >	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 >	UNIT_ADD (charge, petaampere_hour, petaampere_hours, PAh, peta< ampere_hours >) namespace traits
template<>
constexpr const char *	name (const energy::joule_t &)
template<>
constexpr const char *	abbreviation (const energy::joule_t &)
template<>
constexpr const char *	name_plural (const energy::joule_t &)
	UNIT_ADD_LITERALS (energy, joule, J) UNIT_ADD(energy
femto< joules >	UNIT_ADD (energy, picojoule, picojoules, pJ, pico< joules >) UNIT_ADD(energy
femto< joules > nano< joules >	UNIT_ADD (energy, microjoule, microjoules, uJ, micro< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules >	UNIT_ADD (energy, centijoule, centijoules, cJ, centi< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules >	UNIT_ADD (energy, decajoule, decajoules, daJ, deca< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules >	UNIT_ADD (energy, kilojoule, kilojoules, kJ, kilo< joules >) UNIT_ADD(energy
femto< joules > nano< joules > milli< joules > deci< joules > hecto< joules > mega< joules >	UNIT_ADD (energy, gigajoule, gigajoules, GJ, giga< joules >) UNIT_ADD(energy
template<>
constexpr const char *	name (const energy::calorie_t &)
template<>
constexpr const char *	abbreviation (const energy::calorie_t &)
template<>
constexpr const char *	name_plural (const energy::calorie_t &)
	UNIT_ADD_LITERALS (energy, calorie, cal) UNIT_ADD(energy
femto< calories >	UNIT_ADD (energy, picocalorie, picocalories, pcal, pico< calories >) UNIT_ADD(energy
femto< calories > nano< calories >	UNIT_ADD (energy, microcalorie, microcalories, ucal, micro< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories >	UNIT_ADD (energy, centicalorie, centicalories, ccal, centi< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories >	UNIT_ADD (energy, decacalorie, decacalories, dacal, deca< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories >	UNIT_ADD (energy, kilocalorie, kilocalories, kcal, kilo< calories >) UNIT_ADD(energy
femto< calories > nano< calories > milli< calories > deci< calories > hecto< calories > mega< calories >	UNIT_ADD (energy, gigacalorie, gigacalories, Gcal, giga< calories >) UNIT_ADD(energy
template<>
constexpr const char *	name (const energy::kilowatt_hour_t &)
template<>
constexpr const char *	abbreviation (const energy::kilowatt_hour_t &)
template<>
constexpr const char *	name_plural (const energy::kilowatt_hour_t &)
template<>
constexpr const char *	name (const energy::watt_hour_t &)
template<>
constexpr const char *	abbreviation (const energy::watt_hour_t &)
template<>
constexpr const char *	name_plural (const energy::watt_hour_t &)
template<>
constexpr const char *	name (const energy::british_thermal_unit_t &)
template<>
constexpr const char *	abbreviation (const energy::british_thermal_unit_t &)
template<>
constexpr const char *	name_plural (const energy::british_thermal_unit_t &)
template<>
constexpr const char *	name (const energy::british_thermal_unit_iso_t &)
template<>
constexpr const char *	abbreviation (const energy::british_thermal_unit_iso_t &)
template<>
constexpr const char *	name_plural (const energy::british_thermal_unit_iso_t &)
template<>
constexpr const char *	name (const energy::british_thermal_unit_59_t &)
template<>
constexpr const char *	abbreviation (const energy::british_thermal_unit_59_t &)
template<>
constexpr const char *	name_plural (const energy::british_thermal_unit_59_t &)
template<>
constexpr const char *	name (const energy::therm_t &)
template<>
constexpr const char *	abbreviation (const energy::therm_t &)
template<>
constexpr const char *	name_plural (const energy::therm_t &)
template<>
constexpr const char *	name (const energy::foot_pound_t &)
template<>
constexpr const char *	abbreviation (const energy::foot_pound_t &)
template<>
constexpr const char *	name_plural (const energy::foot_pound_t &)
	UNIT_ADD_LITERALS (energy, foot_pound, ftlbf) namespace traits
template<>
constexpr const char *	name (const power::watt_t &)
template<>
constexpr const char *	abbreviation (const power::watt_t &)
template<>
constexpr const char *	name_plural (const power::watt_t &)
	UNIT_ADD_LITERALS (power, watt, W) UNIT_ADD(power
femto< watts >	UNIT_ADD (power, picowatt, picowatts, pW, pico< watts >) UNIT_ADD(power
femto< watts > nano< watts >	UNIT_ADD (power, microwatt, microwatts, uW, micro< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts >	UNIT_ADD (power, centiwatt, centiwatts, cW, centi< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts >	UNIT_ADD (power, decawatt, decawatts, daW, deca< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts >	UNIT_ADD (power, kilowatt, kilowatts, kW, kilo< watts >) UNIT_ADD(power
femto< watts > nano< watts > milli< watts > deci< watts > hecto< watts > mega< watts >	UNIT_ADD (power, gigawatt, gigawatts, GW, giga< watts >) UNIT_ADD(power
template<>
constexpr const char *	name (const power::horsepower_t &)
template<>
constexpr const char *	abbreviation (const power::horsepower_t &)
template<>
constexpr const char *	name_plural (const power::horsepower_t &)
	UNIT_ADD_LITERALS (power, dBm, dBm) namespace traits
template<>
constexpr const char *	name (const voltage::volt_t &)
template<>
constexpr const char *	abbreviation (const voltage::volt_t &)
template<>
constexpr const char *	name_plural (const voltage::volt_t &)
	UNIT_ADD_LITERALS (voltage, volt, V) UNIT_ADD(voltage
femto< volts >	UNIT_ADD (voltage, picovolt, picovolts, pV, pico< volts >) UNIT_ADD(voltage
femto< volts > nano< volts >	UNIT_ADD (voltage, microvolt, microvolts, uV, micro< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts >	UNIT_ADD (voltage, centivolt, centivolts, cV, centi< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts >	UNIT_ADD (voltage, decavolt, decavolts, daV, deca< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts >	UNIT_ADD (voltage, kilovolt, kilovolts, kV, kilo< volts >) UNIT_ADD(voltage
femto< volts > nano< volts > milli< volts > deci< volts > hecto< volts > mega< volts >	UNIT_ADD (voltage, gigavolt, gigavolts, GV, giga< volts >) UNIT_ADD(voltage
template<>
constexpr const char *	name (const voltage::statvolt_t &)
template<>
constexpr const char *	abbreviation (const voltage::statvolt_t &)
template<>
constexpr const char *	name_plural (const voltage::statvolt_t &)
template<>
constexpr const char *	name (const voltage::abvolt_t &)
template<>
constexpr const char *	abbreviation (const voltage::abvolt_t &)
template<>
constexpr const char *	name_plural (const voltage::abvolt_t &)
	UNIT_ADD_LITERALS (voltage, abvolt, abV) namespace traits
template<>
constexpr const char *	name (const capacitance::farad_t &)
template<>
constexpr const char *	abbreviation (const capacitance::farad_t &)
template<>
constexpr const char *	name_plural (const capacitance::farad_t &)
	UNIT_ADD_LITERALS (capacitance, farad, F) UNIT_ADD(capacitance
femto< farads >	UNIT_ADD (capacitance, picofarad, picofarads, pF, pico< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads >	UNIT_ADD (capacitance, microfarad, microfarads, uF, micro< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads >	UNIT_ADD (capacitance, centifarad, centifarads, cF, centi< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads >	UNIT_ADD (capacitance, decafarad, decafarads, daF, deca< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads >	UNIT_ADD (capacitance, kilofarad, kilofarads, kF, kilo< farads >) UNIT_ADD(capacitance
femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads >	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 >	UNIT_ADD (capacitance, petafarad, petafarads, PF, peta< farads >) namespace traits
template<>
constexpr const char *	name (const impedance::ohm_t &)
template<>
constexpr const char *	abbreviation (const impedance::ohm_t &)
template<>
constexpr const char *	name_plural (const impedance::ohm_t &)
	UNIT_ADD_LITERALS (impedance, ohm, Ohm) UNIT_ADD(impedance
femto< ohms >	UNIT_ADD (impedance, picoohm, picoohms, pOhm, pico< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms >	UNIT_ADD (impedance, microohm, microohms, uOhm, micro< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms >	UNIT_ADD (impedance, centiohm, centiohms, cOhm, centi< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms >	UNIT_ADD (impedance, decaohm, decaohms, daOhm, deca< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms >	UNIT_ADD (impedance, kiloohm, kiloohms, kOhm, kilo< ohms >) UNIT_ADD(impedance
femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms >	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 >	UNIT_ADD (impedance, petaohm, petaohms, POhm, peta< ohms >) namespace traits
template<>
constexpr const char *	name (const conductance::siemens_t &)
template<>
constexpr const char *	abbreviation (const conductance::siemens_t &)
template<>
constexpr const char *	name_plural (const conductance::siemens_t &)
	UNIT_ADD_LITERALS (conductance, siemens, S) UNIT_ADD(conductance
femto< siemens >	UNIT_ADD (conductance, picosiemens, picosiemens, pS, pico< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens >	UNIT_ADD (conductance, microsiemens, microsiemens, uS, micro< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens >	UNIT_ADD (conductance, centisiemens, centisiemens, cS, centi< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens >	UNIT_ADD (conductance, decasiemens, decasiemens, daS, deca< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens >	UNIT_ADD (conductance, kilosiemens, kilosiemens, kS, kilo< siemens >) UNIT_ADD(conductance
femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens >	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 >	UNIT_ADD (conductance, petasiemens, petasiemens, PS, peta< siemens >) namespace traits
template<>
constexpr const char *	name (const magnetic_flux::weber_t &)
template<>
constexpr const char *	abbreviation (const magnetic_flux::weber_t &)
template<>
constexpr const char *	name_plural (const magnetic_flux::weber_t &)
	UNIT_ADD_LITERALS (magnetic_flux, weber, Wb) UNIT_ADD(magnetic_flux
femto< webers >	UNIT_ADD (magnetic_flux, picoweber, picowebers, pWb, pico< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers >	UNIT_ADD (magnetic_flux, microweber, microwebers, uWb, micro< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers >	UNIT_ADD (magnetic_flux, centiweber, centiwebers, cWb, centi< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers > deci< webers >	UNIT_ADD (magnetic_flux, decaweber, decawebers, daWb, deca< webers >) UNIT_ADD(magnetic_flux
femto< webers > nano< webers > milli< webers > deci< webers > hecto< webers >	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 >	UNIT_ADD (magnetic_flux, gigaweber, gigawebers, GWb, giga< webers >) UNIT_ADD(magnetic_flux
template<>
constexpr const char *	name (const magnetic_flux::maxwell_t &)
template<>
constexpr const char *	abbreviation (const magnetic_flux::maxwell_t &)
template<>
constexpr const char *	name_plural (const magnetic_flux::maxwell_t &)
	UNIT_ADD_LITERALS (magnetic_flux, maxwell, Mx) namespace traits
template<>
constexpr const char *	name (const magnetic_field_strength::tesla_t &)
template<>
constexpr const char *	abbreviation (const magnetic_field_strength::tesla_t &)
template<>
constexpr const char *	name_plural (const magnetic_field_strength::tesla_t &)
	UNIT_ADD_LITERALS (magnetic_field_strength, tesla, Te) UNIT_ADD(magnetic_field_strength
femto< teslas >	UNIT_ADD (magnetic_field_strength, picotesla, picoteslas, pTe, pico< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas >	UNIT_ADD (magnetic_field_strength, microtesla, microteslas, uTe, micro< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas >	UNIT_ADD (magnetic_field_strength, centitesla, centiteslas, cTe, centi< teslas >) UNIT_ADD(magnetic_field_strength
femto< teslas > nano< teslas > milli< teslas > deci< teslas >	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 >	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 >	UNIT_ADD (magnetic_field_strength, gigatesla, gigateslas, GTe, giga< teslas >) UNIT_ADD(magnetic_field_strength
template<>
constexpr const char *	name (const magnetic_field_strength::gauss_t &)
template<>
constexpr const char *	abbreviation (const magnetic_field_strength::gauss_t &)
template<>
constexpr const char *	name_plural (const magnetic_field_strength::gauss_t &)
	UNIT_ADD_LITERALS (magnetic_field_strength, gauss, G) namespace traits
template<>
constexpr const char *	name (const inductance::henry_t &)
template<>
constexpr const char *	abbreviation (const inductance::henry_t &)
template<>
constexpr const char *	name_plural (const inductance::henry_t &)
	UNIT_ADD_LITERALS (inductance, henry, H) UNIT_ADD(inductance
femto< henries >	UNIT_ADD (inductance, picohenry, picohenries, pH, pico< henries >) UNIT_ADD(inductance
femto< henries > nano< henries >	UNIT_ADD (inductance, microhenry, microhenries, uH, micro< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries >	UNIT_ADD (inductance, centihenry, centihenries, cH, centi< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries >	UNIT_ADD (inductance, decahenry, decahenries, daH, deca< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries >	UNIT_ADD (inductance, kilohenry, kilohenries, kH, kilo< henries >) UNIT_ADD(inductance
femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries >	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 >	UNIT_ADD (inductance, petahenry, petahenries, PH, peta< henries >) namespace traits
template<>
constexpr const char *	name (const luminous_flux::lumen_t &)
template<>
constexpr const char *	abbreviation (const luminous_flux::lumen_t &)
template<>
constexpr const char *	name_plural (const luminous_flux::lumen_t &)
	UNIT_ADD_LITERALS (luminous_flux, lumen, lm) UNIT_ADD(luminous_flux
femto< lumens >	UNIT_ADD (luminous_flux, picolumen, picolumens, plm, pico< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens >	UNIT_ADD (luminous_flux, microlumen, microlumens, ulm, micro< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens >	UNIT_ADD (luminous_flux, centilumen, centilumens, clm, centi< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens >	UNIT_ADD (luminous_flux, decalumen, decalumens, dalm, deca< lumens >) UNIT_ADD(luminous_flux
femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens >	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 >	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 >	UNIT_ADD (luminous_flux, petalumen, petalumens, Plm, peta< lumens >) namespace traits
template<>
constexpr const char *	name (const illuminance::lux_t &)
template<>
constexpr const char *	abbreviation (const illuminance::lux_t &)
template<>
constexpr const char *	name_plural (const illuminance::lux_t &)
	UNIT_ADD_LITERALS (illuminance, lux, lx) UNIT_ADD(illuminance
femto< luxes >	UNIT_ADD (illuminance, picolux, picoluxes, plx, pico< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes >	UNIT_ADD (illuminance, microlux, microluxes, ulx, micro< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes >	UNIT_ADD (illuminance, centilux, centiluxes, clx, centi< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes >	UNIT_ADD (illuminance, decalux, decaluxes, dalx, deca< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes >	UNIT_ADD (illuminance, kilolux, kiloluxes, klx, kilo< luxes >) UNIT_ADD(illuminance
femto< luxes > nano< luxes > milli< luxes > deci< luxes > hecto< luxes > mega< luxes >	UNIT_ADD (illuminance, gigalux, gigaluxes, Glx, giga< luxes >) UNIT_ADD(illuminance
template<>
constexpr const char *	name (const illuminance::footcandle_t &)
template<>
constexpr const char *	abbreviation (const illuminance::footcandle_t &)
template<>
constexpr const char *	name_plural (const illuminance::footcandle_t &)
template<>
constexpr const char *	name (const illuminance::lumens_per_square_inch_t &)
template<>
constexpr const char *	abbreviation (const illuminance::lumens_per_square_inch_t &)
template<>
constexpr const char *	name_plural (const illuminance::lumens_per_square_inch_t &)
template<>
constexpr const char *	name (const illuminance::phot_t &)
template<>
constexpr const char *	abbreviation (const illuminance::phot_t &)
template<>
constexpr const char *	name_plural (const illuminance::phot_t &)
	UNIT_ADD_LITERALS (illuminance, phot, ph) namespace traits
template<>
constexpr const char *	name (const radiation::becquerel_t &)
template<>
constexpr const char *	abbreviation (const radiation::becquerel_t &)
template<>
constexpr const char *	name_plural (const radiation::becquerel_t &)
	UNIT_ADD_LITERALS (radiation, becquerel, Bq) UNIT_ADD(radiation
femto< becquerels >	UNIT_ADD (radiation, picobecquerel, picobecquerels, pBq, pico< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels >	UNIT_ADD (radiation, microbecquerel, microbecquerels, uBq, micro< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels >	UNIT_ADD (radiation, centibecquerel, centibecquerels, cBq, centi< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels >	UNIT_ADD (radiation, decabecquerel, decabecquerels, daBq, deca< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels >	UNIT_ADD (radiation, kilobecquerel, kilobecquerels, kBq, kilo< becquerels >) UNIT_ADD(radiation
femto< becquerels > nano< becquerels > milli< becquerels > deci< becquerels > hecto< becquerels > mega< becquerels >	UNIT_ADD (radiation, gigabecquerel, gigabecquerels, GBq, giga< becquerels >) UNIT_ADD(radiation
template<>
constexpr const char *	name (const radiation::gray_t &)
template<>
constexpr const char *	abbreviation (const radiation::gray_t &)
template<>
constexpr const char *	name_plural (const radiation::gray_t &)
	UNIT_ADD_LITERALS (radiation, gray, Gy) UNIT_ADD(radiation
femto< grays >	UNIT_ADD (radiation, picogray, picograys, pGy, pico< grays >) UNIT_ADD(radiation
femto< grays > nano< grays >	UNIT_ADD (radiation, microgray, micrograys, uGy, micro< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays >	UNIT_ADD (radiation, centigray, centigrays, cGy, centi< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays >	UNIT_ADD (radiation, decagray, decagrays, daGy, deca< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays >	UNIT_ADD (radiation, kilogray, kilograys, kGy, kilo< grays >) UNIT_ADD(radiation
femto< grays > nano< grays > milli< grays > deci< grays > hecto< grays > mega< grays >	UNIT_ADD (radiation, gigagray, gigagrays, GGy, giga< grays >) UNIT_ADD(radiation
template<>
constexpr const char *	name (const radiation::sievert_t &)
template<>
constexpr const char *	abbreviation (const radiation::sievert_t &)
template<>
constexpr const char *	name_plural (const radiation::sievert_t &)
	UNIT_ADD_LITERALS (radiation, sievert, Sv) UNIT_ADD(radiation
femto< sieverts >	UNIT_ADD (radiation, picosievert, picosieverts, pSv, pico< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts >	UNIT_ADD (radiation, microsievert, microsieverts, uSv, micro< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts >	UNIT_ADD (radiation, centisievert, centisieverts, cSv, centi< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts >	UNIT_ADD (radiation, decasievert, decasieverts, daSv, deca< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts >	UNIT_ADD (radiation, kilosievert, kilosieverts, kSv, kilo< sieverts >) UNIT_ADD(radiation
femto< sieverts > nano< sieverts > milli< sieverts > deci< sieverts > hecto< sieverts > mega< sieverts >	UNIT_ADD (radiation, gigasievert, gigasieverts, GSv, giga< sieverts >) UNIT_ADD(radiation
template<>
constexpr const char *	name (const radiation::curie_t &)
template<>
constexpr const char *	abbreviation (const radiation::curie_t &)
template<>
constexpr const char *	name_plural (const radiation::curie_t &)
template<>
constexpr const char *	name (const radiation::rutherford_t &)
template<>
constexpr const char *	abbreviation (const radiation::rutherford_t &)
template<>
constexpr const char *	name_plural (const radiation::rutherford_t &)
template<>
constexpr const char *	name (const radiation::rad_t &)
template<>
constexpr const char *	abbreviation (const radiation::rad_t &)
template<>
constexpr const char *	name_plural (const radiation::rad_t &)
	UNIT_ADD_LITERALS (radiation, rad, rads) namespace traits
template<>
constexpr const char *	name (const torque::newton_meter_t &)
template<>
constexpr const char *	abbreviation (const torque::newton_meter_t &)
template<>
constexpr const char *	name_plural (const torque::newton_meter_t &)
template<>
constexpr const char *	name (const torque::foot_pound_t &)
template<>
constexpr const char *	abbreviation (const torque::foot_pound_t &)
template<>
constexpr const char *	name_plural (const torque::foot_pound_t &)
template<>
constexpr const char *	name (const torque::foot_poundal_t &)
template<>
constexpr const char *	abbreviation (const torque::foot_poundal_t &)
template<>
constexpr const char *	name_plural (const torque::foot_poundal_t &)
template<>
constexpr const char *	name (const torque::inch_pound_t &)
template<>
constexpr const char *	abbreviation (const torque::inch_pound_t &)
template<>
constexpr const char *	name_plural (const torque::inch_pound_t &)
template<>
constexpr const char *	name (const torque::meter_kilogram_t &)
template<>
constexpr const char *	abbreviation (const torque::meter_kilogram_t &)
template<>
constexpr const char *	name_plural (const torque::meter_kilogram_t &)
	UNIT_ADD_LITERALS (torque, meter_kilogram, mkgf) namespace traits
template<>
constexpr const char *	name (const area::square_meter_t &)
template<>
constexpr const char *	abbreviation (const area::square_meter_t &)
template<>
constexpr const char *	name_plural (const area::square_meter_t &)
template<>
constexpr const char *	name (const area::square_foot_t &)
template<>
constexpr const char *	abbreviation (const area::square_foot_t &)
template<>
constexpr const char *	name_plural (const area::square_foot_t &)
template<>
constexpr const char *	name (const area::square_inch_t &)
template<>
constexpr const char *	abbreviation (const area::square_inch_t &)
template<>
constexpr const char *	name_plural (const area::square_inch_t &)
template<>
constexpr const char *	name (const area::square_mile_t &)
template<>
constexpr const char *	abbreviation (const area::square_mile_t &)
template<>
constexpr const char *	name_plural (const area::square_mile_t &)
template<>
constexpr const char *	name (const area::square_kilometer_t &)
template<>
constexpr const char *	abbreviation (const area::square_kilometer_t &)
template<>
constexpr const char *	name_plural (const area::square_kilometer_t &)
template<>
constexpr const char *	name (const area::hectare_t &)
template<>
constexpr const char *	abbreviation (const area::hectare_t &)
template<>
constexpr const char *	name_plural (const area::hectare_t &)
template<>
constexpr const char *	name (const area::acre_t &)
template<>
constexpr const char *	abbreviation (const area::acre_t &)
template<>
constexpr const char *	name_plural (const area::acre_t &)
	UNIT_ADD_LITERALS (area, acre, acre) namespace traits
template<>
constexpr const char *	name (const volume::cubic_meter_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_meter_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_meter_t &)
template<>
constexpr const char *	name (const volume::cubic_millimeter_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_millimeter_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_millimeter_t &)
template<>
constexpr const char *	name (const volume::cubic_kilometer_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_kilometer_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_kilometer_t &)
template<>
constexpr const char *	name (const volume::liter_t &)
template<>
constexpr const char *	abbreviation (const volume::liter_t &)
template<>
constexpr const char *	name_plural (const volume::liter_t &)
	UNIT_ADD_LITERALS (volume, liter, L) UNIT_ADD(volume
femto< liters >	UNIT_ADD (volume, picoliter, picoliters, pL, pico< liters >) UNIT_ADD(volume
femto< liters > nano< liters >	UNIT_ADD (volume, microliter, microliters, uL, micro< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters >	UNIT_ADD (volume, centiliter, centiliters, cL, centi< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters >	UNIT_ADD (volume, decaliter, decaliters, daL, deca< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters >	UNIT_ADD (volume, kiloliter, kiloliters, kL, kilo< liters >) UNIT_ADD(volume
femto< liters > nano< liters > milli< liters > deci< liters > hecto< liters > mega< liters >	UNIT_ADD (volume, gigaliter, gigaliters, GL, giga< liters >) UNIT_ADD(volume
template<>
constexpr const char *	name (const volume::cubic_inch_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_inch_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_inch_t &)
template<>
constexpr const char *	name (const volume::cubic_foot_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_foot_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_foot_t &)
template<>
constexpr const char *	name (const volume::cubic_yard_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_yard_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_yard_t &)
template<>
constexpr const char *	name (const volume::cubic_mile_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_mile_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_mile_t &)
template<>
constexpr const char *	name (const volume::gallon_t &)
template<>
constexpr const char *	abbreviation (const volume::gallon_t &)
template<>
constexpr const char *	name_plural (const volume::gallon_t &)
template<>
constexpr const char *	name (const volume::quart_t &)
template<>
constexpr const char *	abbreviation (const volume::quart_t &)
template<>
constexpr const char *	name_plural (const volume::quart_t &)
template<>
constexpr const char *	name (const volume::pint_t &)
template<>
constexpr const char *	abbreviation (const volume::pint_t &)
template<>
constexpr const char *	name_plural (const volume::pint_t &)
template<>
constexpr const char *	name (const volume::cup_t &)
template<>
constexpr const char *	abbreviation (const volume::cup_t &)
template<>
constexpr const char *	name_plural (const volume::cup_t &)
template<>
constexpr const char *	name (const volume::fluid_ounce_t &)
template<>
constexpr const char *	abbreviation (const volume::fluid_ounce_t &)
template<>
constexpr const char *	name_plural (const volume::fluid_ounce_t &)
template<>
constexpr const char *	name (const volume::barrel_t &)
template<>
constexpr const char *	abbreviation (const volume::barrel_t &)
template<>
constexpr const char *	name_plural (const volume::barrel_t &)
template<>
constexpr const char *	name (const volume::bushel_t &)
template<>
constexpr const char *	abbreviation (const volume::bushel_t &)
template<>
constexpr const char *	name_plural (const volume::bushel_t &)
template<>
constexpr const char *	name (const volume::cord_t &)
template<>
constexpr const char *	abbreviation (const volume::cord_t &)
template<>
constexpr const char *	name_plural (const volume::cord_t &)
template<>
constexpr const char *	name (const volume::cubic_fathom_t &)
template<>
constexpr const char *	abbreviation (const volume::cubic_fathom_t &)
template<>
constexpr const char *	name_plural (const volume::cubic_fathom_t &)
template<>
constexpr const char *	name (const volume::tablespoon_t &)
template<>
constexpr const char *	abbreviation (const volume::tablespoon_t &)
template<>
constexpr const char *	name_plural (const volume::tablespoon_t &)
template<>
constexpr const char *	name (const volume::teaspoon_t &)
template<>
constexpr const char *	abbreviation (const volume::teaspoon_t &)
template<>
constexpr const char *	name_plural (const volume::teaspoon_t &)
template<>
constexpr const char *	name (const volume::pinch_t &)
template<>
constexpr const char *	abbreviation (const volume::pinch_t &)
template<>
constexpr const char *	name_plural (const volume::pinch_t &)
template<>
constexpr const char *	name (const volume::dash_t &)
template<>
constexpr const char *	abbreviation (const volume::dash_t &)
template<>
constexpr const char *	name_plural (const volume::dash_t &)
template<>
constexpr const char *	name (const volume::drop_t &)
template<>
constexpr const char *	abbreviation (const volume::drop_t &)
template<>
constexpr const char *	name_plural (const volume::drop_t &)
template<>
constexpr const char *	name (const volume::fifth_t &)
template<>
constexpr const char *	abbreviation (const volume::fifth_t &)
template<>
constexpr const char *	name_plural (const volume::fifth_t &)
template<>
constexpr const char *	name (const volume::dram_t &)
template<>
constexpr const char *	abbreviation (const volume::dram_t &)
template<>
constexpr const char *	name_plural (const volume::dram_t &)
template<>
constexpr const char *	name (const volume::gill_t &)
template<>
constexpr const char *	abbreviation (const volume::gill_t &)
template<>
constexpr const char *	name_plural (const volume::gill_t &)
template<>
constexpr const char *	name (const volume::peck_t &)
template<>
constexpr const char *	abbreviation (const volume::peck_t &)
template<>
constexpr const char *	name_plural (const volume::peck_t &)
template<>
constexpr const char *	name (const volume::sack_t &)
template<>
constexpr const char *	abbreviation (const volume::sack_t &)
template<>
constexpr const char *	name_plural (const volume::sack_t &)
template<>
constexpr const char *	name (const volume::shot_t &)
template<>
constexpr const char *	abbreviation (const volume::shot_t &)
template<>
constexpr const char *	name_plural (const volume::shot_t &)
template<>
constexpr const char *	name (const volume::strike_t &)
template<>
constexpr const char *	abbreviation (const volume::strike_t &)
template<>
constexpr const char *	name_plural (const volume::strike_t &)
	UNIT_ADD_LITERALS (volume, strike, strikes) namespace traits
template<>
constexpr const char *	name (const density::kilograms_per_cubic_meter_t &)
template<>
constexpr const char *	abbreviation (const density::kilograms_per_cubic_meter_t &)
template<>
constexpr const char *	name_plural (const density::kilograms_per_cubic_meter_t &)
template<>
constexpr const char *	name (const density::grams_per_milliliter_t &)
template<>
constexpr const char *	abbreviation (const density::grams_per_milliliter_t &)
template<>
constexpr const char *	name_plural (const density::grams_per_milliliter_t &)
template<>
constexpr const char *	name (const density::kilograms_per_liter_t &)
template<>
constexpr const char *	abbreviation (const density::kilograms_per_liter_t &)
template<>
constexpr const char *	name_plural (const density::kilograms_per_liter_t &)
template<>
constexpr const char *	name (const density::ounces_per_cubic_foot_t &)
template<>
constexpr const char *	abbreviation (const density::ounces_per_cubic_foot_t &)
template<>
constexpr const char *	name_plural (const density::ounces_per_cubic_foot_t &)
template<>
constexpr const char *	name (const density::ounces_per_cubic_inch_t &)
template<>
constexpr const char *	abbreviation (const density::ounces_per_cubic_inch_t &)
template<>
constexpr const char *	name_plural (const density::ounces_per_cubic_inch_t &)
template<>
constexpr const char *	name (const density::ounces_per_gallon_t &)
template<>
constexpr const char *	abbreviation (const density::ounces_per_gallon_t &)
template<>
constexpr const char *	name_plural (const density::ounces_per_gallon_t &)
template<>
constexpr const char *	name (const density::pounds_per_cubic_foot_t &)
template<>
constexpr const char *	abbreviation (const density::pounds_per_cubic_foot_t &)
template<>
constexpr const char *	name_plural (const density::pounds_per_cubic_foot_t &)
template<>
constexpr const char *	name (const density::pounds_per_cubic_inch_t &)
template<>
constexpr const char *	abbreviation (const density::pounds_per_cubic_inch_t &)
template<>
constexpr const char *	name_plural (const density::pounds_per_cubic_inch_t &)
template<>
constexpr const char *	name (const density::pounds_per_gallon_t &)
template<>
constexpr const char *	abbreviation (const density::pounds_per_gallon_t &)
template<>
constexpr const char *	name_plural (const density::pounds_per_gallon_t &)
template<>
constexpr const char *	name (const density::slugs_per_cubic_foot_t &)
template<>
constexpr const char *	abbreviation (const density::slugs_per_cubic_foot_t &)
template<>
constexpr const char *	name_plural (const density::slugs_per_cubic_foot_t &)
	UNIT_ADD_LITERALS (density, slugs_per_cubic_foot, slug_per_cu_ft) namespace traits
template<>
constexpr const char *	name (const concentration::ppm_t &)
template<>
constexpr const char *	abbreviation (const concentration::ppm_t &)
template<>
constexpr const char *	name_plural (const concentration::ppm_t &)
template<>
constexpr const char *	name (const concentration::ppb_t &)
template<>
constexpr const char *	abbreviation (const concentration::ppb_t &)
template<>
constexpr const char *	name_plural (const concentration::ppb_t &)
template<>
constexpr const char *	name (const concentration::ppt_t &)
template<>
constexpr const char *	abbreviation (const concentration::ppt_t &)
template<>
constexpr const char *	name_plural (const concentration::ppt_t &)
template<>
constexpr const char *	name (const concentration::percent_t &)
template<>
constexpr const char *	abbreviation (const concentration::percent_t &)
template<>
constexpr const char *	name_plural (const concentration::percent_t &)
	UNIT_ADD_LITERALS (concentration, percent, pct) namespace traits
template<>
constexpr const char *	name (const data::byte_t &)
template<>
constexpr const char *	abbreviation (const data::byte_t &)
template<>
constexpr const char *	name_plural (const data::byte_t &)
	UNIT_ADD_LITERALS (data, byte, B) UNIT_ADD(data
femto< bytes >	UNIT_ADD (data, picobyte, picobytes, pB, pico< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes >	UNIT_ADD (data, microbyte, microbytes, uB, micro< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes >	UNIT_ADD (data, centibyte, centibytes, cB, centi< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes >	UNIT_ADD (data, decabyte, decabytes, daB, deca< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes >	UNIT_ADD (data, kilobyte, kilobytes, kB, kilo< bytes >) UNIT_ADD(data
femto< bytes > nano< bytes > milli< bytes > deci< bytes > hecto< bytes > mega< bytes >	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 >	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 >	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 >	UNIT_ADD (data, tebibyte, tebibytes, TiB, tebi< bytes >) UNIT_ADD(data
template<>
constexpr const char *	name (const data::exabyte_t &)
template<>
constexpr const char *	abbreviation (const data::exabyte_t &)
template<>
constexpr const char *	name_plural (const data::exabyte_t &)
template<>
constexpr const char *	name (const data::bit_t &)
template<>
constexpr const char *	abbreviation (const data::bit_t &)
template<>
constexpr const char *	name_plural (const data::bit_t &)
	UNIT_ADD_LITERALS (data, bit, b) UNIT_ADD(data
femto< bits >	UNIT_ADD (data, picobit, picobits, pb, pico< bits >) UNIT_ADD(data
femto< bits > nano< bits >	UNIT_ADD (data, microbit, microbits, ub, micro< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits >	UNIT_ADD (data, centibit, centibits, cb, centi< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits >	UNIT_ADD (data, decabit, decabits, dab, deca< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits >	UNIT_ADD (data, kilobit, kilobits, kb, kilo< bits >) UNIT_ADD(data
femto< bits > nano< bits > milli< bits > deci< bits > hecto< bits > mega< bits >	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 >	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 >	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 >	UNIT_ADD (data, tebibit, tebibits, Tib, tebi< bits >) UNIT_ADD(data
template<>
constexpr const char *	name (const data::exabit_t &)
template<>
constexpr const char *	abbreviation (const data::exabit_t &)
template<>
constexpr const char *	name_plural (const data::exabit_t &)
	UNIT_ADD_LITERALS (data, exabit, Eb) namespace traits
template<>
constexpr const char *	name (const data_transfer_rate::bytes_per_second_t &)
template<>
constexpr const char *	abbreviation (const data_transfer_rate::bytes_per_second_t &)
template<>
constexpr const char *	name_plural (const data_transfer_rate::bytes_per_second_t &)
	UNIT_ADD_LITERALS (data_transfer_rate, bytes_per_second, Bps) UNIT_ADD(data_transfer_rate
femto< bytes_per_second >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 *	name (const data_transfer_rate::exabytes_per_second_t &)
template<>
constexpr const char *	abbreviation (const data_transfer_rate::exabytes_per_second_t &)
template<>
constexpr const char *	name_plural (const data_transfer_rate::exabytes_per_second_t &)
template<>
constexpr const char *	name (const data_transfer_rate::bits_per_second_t &)
template<>
constexpr const char *	abbreviation (const data_transfer_rate::bits_per_second_t &)
template<>
constexpr const char *	name_plural (const data_transfer_rate::bits_per_second_t &)
	UNIT_ADD_LITERALS (data_transfer_rate, bits_per_second, bps) UNIT_ADD(data_transfer_rate
femto< bits_per_second >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 *	name (const data_transfer_rate::exabits_per_second_t &)
template<>
constexpr const char *	abbreviation (const data_transfer_rate::exabits_per_second_t &)
template<>
constexpr const char *	name_plural (const data_transfer_rate::exabits_per_second_t &)
	UNIT_ADD_LITERALS (data_transfer_rate, exabits_per_second, Ebps) namespace traits

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

Detailed Description

Unit Conversion Library namespace.

Function Documentation

operator*() [1/2]

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>

auto units::operator* ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs ) -> unit_t< compound_unit< squared< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type > > >

inlineconstexprnoexcept

Multiplication type for convertible unit_t types with a linear scale.

Returns

the multiplied value, with the same type as left-hand side unit.

operator*() [2/2]

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>

auto units::operator* ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs ) -> unit_t< compound_unit< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type, typename units::traits::unit_t_traits< UnitTypeRhs >::unit_type > >

inlineconstexprnoexcept

Multiplication type for non-convertible unit_t types with a linear scale.

Returns

the multiplied value, whose type is a compound unit of the left and right hand side values.

operator/() [1/2]

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>

dimensionless::scalar_t units::operator/ ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs )

inlineconstexprnoexcept

Division for convertible unit_t types with a linear scale.

Returns

the lhs divided by rhs value, whose type is a scalar

operator/() [2/2]

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>

auto units::operator/ ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs ) -> unit_t< compound_unit< typename units::traits::unit_t_traits< UnitTypeLhs >::unit_type, inverse< typename units::traits::unit_t_traits< UnitTypeRhs >::unit_type > > >

inlineconstexprnoexcept

Division for non-convertible unit_t types with a linear scale.

Returns

the lhs divided by the rhs, with a compound unit type of lhs/rhs

UNIT_ADD() [1/9]

femto< farads > nano< farads > milli< farads > deci< farads > hecto< farads > mega< farads > tera< farads > units::UNIT_ADD	(	capacitance	,
		petafarad	,
		petafarads	,
		PF	,
		peta< farads >	)

@cond

@endcond

UNIT_ADD() [2/9]

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

@cond

@endcond

UNIT_ADD() [3/9]

femto< siemens > nano< siemens > milli< siemens > deci< siemens > hecto< siemens > mega< siemens > tera< siemens > units::UNIT_ADD	(	conductance	,
		petasiemens	,
		petasiemens	,
		PS	,
		peta< siemens >	)

@cond

@endcond

UNIT_ADD() [4/9]

femto< amperes > nano< amperes > milli< amperes > deci< amperes > hecto< amperes > mega< amperes > tera< amperes > units::UNIT_ADD	(	current	,
		petaampere	,
		petaamperes	,
		PA	,
		peta< amperes >	)

@cond

@endcond

UNIT_ADD() [5/9]

femto< hertz > nano< hertz > milli< hertz > deci< hertz > hecto< hertz > mega< hertz > tera< hertz > units::UNIT_ADD	(	frequency	,
		petahertz	,
		petahertz	,
		PHz	,
		peta< hertz >	)

@cond

@endcond

UNIT_ADD() [6/9]

femto< ohms > nano< ohms > milli< ohms > deci< ohms > hecto< ohms > mega< ohms > tera< ohms > units::UNIT_ADD	(	impedance	,
		petaohm	,
		petaohms	,
		POhm	,
		peta< ohms >	)

@cond

@endcond

UNIT_ADD() [7/9]

femto< henries > nano< henries > milli< henries > deci< henries > hecto< henries > mega< henries > tera< henries > units::UNIT_ADD	(	inductance	,
		petahenry	,
		petahenries	,
		PH	,
		peta< henries >	)

@cond

@endcond

UNIT_ADD() [8/9]

femto< lumens > nano< lumens > milli< lumens > deci< lumens > hecto< lumens > mega< lumens > tera< lumens > units::UNIT_ADD	(	luminous_flux	,
		petalumen	,
		petalumens	,
		Plm	,
		peta< lumens >	)

@cond

@endcond

UNIT_ADD() [9/9]

femto< candelas > nano< candelas > milli< candelas > deci< candelas > hecto< candelas > mega< candelas > tera< candelas > units::UNIT_ADD	(	luminous_intensity	,
		petacandela	,
		petacandelas	,
		Pcd	,
		peta< candelas >	)

@cond

@endcond

UNIT_ADD_LITERALS() [1/27]

units::UNIT_ADD_LITERALS	(	acceleration	,
		standard_gravity	,
		SG	)

@cond

@endcond

UNIT_ADD_LITERALS() [2/27]

units::UNIT_ADD_LITERALS	(	angle	,
		gradian	,
		gon	)

@cond

@endcond

UNIT_ADD_LITERALS() [3/27]

units::UNIT_ADD_LITERALS	(	angular_velocity	,
		milliarcseconds_per_year	,
		mas_per_yr	)

@cond

@endcond

UNIT_ADD_LITERALS() [4/27]

units::UNIT_ADD_LITERALS	(	area	,
		acre	,
		acre	)

@cond

@endcond

UNIT_ADD_LITERALS() [5/27]

units::UNIT_ADD_LITERALS	(	concentration	,
		percent	,
		pct	)

@cond

@endcond

UNIT_ADD_LITERALS() [6/27]

units::UNIT_ADD_LITERALS	(	data	,
		exabit	,
		Eb	)

@cond

@endcond

UNIT_ADD_LITERALS() [7/27]

units::UNIT_ADD_LITERALS	(	data_transfer_rate	,
		exabits_per_second	,
		Ebps	)

@cond

@endcond

UNIT_ADD_LITERALS() [8/27]

units::UNIT_ADD_LITERALS	(	density	,
		slugs_per_cubic_foot	,
		slug_per_cu_ft	)

@cond

@endcond

UNIT_ADD_LITERALS() [9/27]

units::UNIT_ADD_LITERALS	(	energy	,
		foot_pound	,
		ftlbf	)

@cond

@endcond

UNIT_ADD_LITERALS() [10/27]

units::UNIT_ADD_LITERALS	(	force	,
		poundal	,
		pdl	)

@cond

@endcond

UNIT_ADD_LITERALS() [11/27]

units::UNIT_ADD_LITERALS	(	illuminance	,
		phot	,
		ph	)

@cond

@endcond

UNIT_ADD_LITERALS() [12/27]

units::UNIT_ADD_LITERALS	(	jerk	,
		feet_per_second_cubed	,
		fps_cb	)

@cond

@endcond

UNIT_ADD_LITERALS() [13/27]

units::UNIT_ADD_LITERALS	(	length	,
		yard	,
		yd	)

@cond

@endcond

UNIT_ADD_LITERALS() [14/27]

units::UNIT_ADD_LITERALS	(	magnetic_field_strength	,
		gauss	,
		G	)

@cond

@endcond

UNIT_ADD_LITERALS() [15/27]

units::UNIT_ADD_LITERALS	(	magnetic_flux	,
		maxwell	,
		Mx	)

@cond

@endcond

UNIT_ADD_LITERALS() [16/27]

units::UNIT_ADD_LITERALS	(	mass	,
		slug	,
		slug	)

@cond

@endcond

UNIT_ADD_LITERALS() [17/27]

units::UNIT_ADD_LITERALS	(	power	,
		dBm	,
		dBm	)

@cond

@endcond

UNIT_ADD_LITERALS() [18/27]

units::UNIT_ADD_LITERALS	(	pressure	,
		inch_of_mercury	,
		inHg	)

@cond

@endcond

UNIT_ADD_LITERALS() [19/27]

units::UNIT_ADD_LITERALS	(	radiation	,
		rad	,
		rads	)

@cond

@endcond

UNIT_ADD_LITERALS() [20/27]

units::UNIT_ADD_LITERALS	(	solid_angle	,
		spat	,
		sp	)

@cond

@endcond

UNIT_ADD_LITERALS() [21/27]

units::UNIT_ADD_LITERALS	(	substance	,
		mole	,
		mol	)

@cond

@endcond

UNIT_ADD_LITERALS() [22/27]

units::UNIT_ADD_LITERALS	(	temperature	,
		rankine	,
		Ra	)

@cond

@endcond

UNIT_ADD_LITERALS() [23/27]

units::UNIT_ADD_LITERALS	(	time	,
		gregorian_year	,
		a_g	)

@cond

@endcond

UNIT_ADD_LITERALS() [24/27]

units::UNIT_ADD_LITERALS	(	torque	,
		meter_kilogram	,
		mkgf	)

@cond

@endcond

UNIT_ADD_LITERALS() [25/27]

units::UNIT_ADD_LITERALS	(	velocity	,
		knot	,
		kts	)

@cond

@endcond

UNIT_ADD_LITERALS() [26/27]

units::UNIT_ADD_LITERALS	(	voltage	,
		abvolt	,
		abV	)

@cond

@endcond

UNIT_ADD_LITERALS() [27/27]

units::UNIT_ADD_LITERALS	(	volume	,
		strike	,
		strikes	)

@cond

@endcond