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

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

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 > > > [inline], [constexpr], [noexcept]

Multiplication type for convertible unit_t types with a linear scale.

Returns

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 > > [inline], [constexpr], [noexcept]

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

Returns

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) [inline], [constexpr], [noexcept]

Division for convertible unit_t types with a linear scale.

Returns

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 > > > [inline], [constexpr], [noexcept]

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

Returns

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

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

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

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

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

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

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

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

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

units::UNIT_ADD_LITERALS (acceleration , standard_gravity , SG )

@cond

@endcond

units::UNIT_ADD_LITERALS (angle , gradian , gon )

@cond

@endcond

units::UNIT_ADD_LITERALS (angular_velocity , milliarcseconds_per_year , mas_per_yr )

@cond

@endcond

units::UNIT_ADD_LITERALS (area , acre , acre )

@cond

@endcond

units::UNIT_ADD_LITERALS (concentration , percent , pct )

@cond

@endcond

units::UNIT_ADD_LITERALS (data , exabit , Eb )

@cond

@endcond

units::UNIT_ADD_LITERALS (data_transfer_rate , exabits_per_second , Ebps )

@cond

@endcond

units::UNIT_ADD_LITERALS (density , slugs_per_cubic_foot , slug_per_cu_ft )

@cond

@endcond

units::UNIT_ADD_LITERALS (energy , foot_pound , ftlbf )

@cond

@endcond

units::UNIT_ADD_LITERALS (force , poundal , pdl )

@cond

@endcond

units::UNIT_ADD_LITERALS (illuminance , phot , ph )

@cond

@endcond

units::UNIT_ADD_LITERALS (jerk , feet_per_second_cubed , fps_cb )

@cond

@endcond

units::UNIT_ADD_LITERALS (length , yard , yd )

@cond

@endcond

units::UNIT_ADD_LITERALS (magnetic_field_strength , gauss , G )

@cond

@endcond

units::UNIT_ADD_LITERALS (magnetic_flux , maxwell , Mx )

@cond

@endcond

units::UNIT_ADD_LITERALS (mass , slug , slug )

@cond

@endcond

units::UNIT_ADD_LITERALS (power , dBm , dBm )

@cond

@endcond

units::UNIT_ADD_LITERALS (pressure , inch_of_mercury , inHg )

@cond

@endcond

units::UNIT_ADD_LITERALS (radiation , rad , rads )

@cond

@endcond

units::UNIT_ADD_LITERALS (solid_angle , spat , sp )

@cond

@endcond

units::UNIT_ADD_LITERALS (substance , mole , mol )

@cond

@endcond

units::UNIT_ADD_LITERALS (temperature , rankine , Ra )

@cond

@endcond

units::UNIT_ADD_LITERALS (time , gregorian_year , a_g )

@cond

@endcond

units::UNIT_ADD_LITERALS (torque , meter_kilogram , mkgf )

@cond

@endcond

units::UNIT_ADD_LITERALS (velocity , knot , kts )

@cond

@endcond

units::UNIT_ADD_LITERALS (voltage , abvolt , abV )

@cond

@endcond

units::UNIT_ADD_LITERALS (volume , strike , strikes )

@cond

@endcond