units Namespace Reference

Unit Conversion Library namespace. More...

Namespaces
namespace	acceleration
	namespace for unit types and containers representing acceleration values
namespace	angle
	namespace for unit types and containers representing angle values
namespace	angular_acceleration
	namespace for unit types and containers representing angular acceleration values
namespace	angular_jerk
	namespace for unit types and containers representing angular jerk values
namespace	angular_velocity
	namespace for unit types and containers representing angular velocity values
namespace	area
	namespace for unit types and containers representing area values
namespace	capacitance
	namespace for unit types and containers representing capacitance values
namespace	category
	namespace representing the implemented base and derived unit types.
namespace	charge
	namespace for unit types and containers representing charge values
namespace	concentration
	namespace for unit types and containers representing concentration values
namespace	conductance
	namespace for unit types and containers representing conductance values
namespace	constants
namespace	current
	namespace for unit types and containers representing current 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	density
	namespace for unit types and containers representing density values
namespace	detail
namespace	dimensionless
	namespace for unit types and containers for units that have no dimension (scalar units)
namespace	energy
	namespace for unit types and containers representing energy values
namespace	force
	namespace for unit types and containers representing force values
namespace	frequency
	namespace for unit types and containers representing frequency values
namespace	illuminance
	namespace for unit types and containers representing illuminance values
namespace	impedance
	namespace for unit types and containers representing impedance values
namespace	inductance
	namespace for unit types and containers representing inductance values
namespace	length
	namespace for unit types and containers representing length values
namespace	literals
namespace	luminous_flux
	namespace for unit types and containers representing luminous_flux values
namespace	luminous_intensity
	namespace for unit types and containers representing luminous_intensity values
namespace	magnetic_field_strength
	namespace for unit types and containers representing magnetic_field_strength values
namespace	magnetic_flux
	namespace for unit types and containers representing magnetic_flux values
namespace	mass
	namespace for unit types and containers representing mass values
namespace	math
	namespace for unit-enabled versions of the <cmath> library
namespace	power
	namespace for unit types and containers representing power values
namespace	pressure
	namespace for unit types and containers representing pressure values
namespace	radiation
	namespace for unit types and containers representing radiation values
namespace	solid_angle
	namespace for unit types and containers representing solid_angle values
namespace	substance
	namespace for unit types and containers representing substance values
namespace	temperature
	namespace for unit types and containers representing temperature values
namespace	time
	namespace for unit types and containers representing time values
namespace	torque
	namespace for unit types and containers representing torque values
namespace	traits
	namespace representing type traits which can access the properties of types provided by the units library.
namespace	velocity
	namespace for unit types and containers representing velocity values
namespace	voltage
	namespace for unit types and containers representing voltage values
namespace	volume
	namespace for unit types and containers representing volume values

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

Typedefs
using	curvature_t
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
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
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
	UNIT_ADD (acceleration, meters_per_second_squared, meters_per_second_squared, mps_sq, unit< std::ratio< 1 >, units::category::acceleration_unit >) UNIT_ADD(acceleration
compound_unit< length::feet, inverse< squared< time::seconds > > >	UNIT_ADD (acceleration, standard_gravity, standard_gravity, SG, unit< std::ratio< 980665, 100000 >, meters_per_second_squared >) using namespace acceleration
	UNIT_ADD_WITH_METRIC_PREFIXES (pressure, pascal, pascals, Pa, unit< std::ratio< 1 >, units::category::pressure_unit >) UNIT_ADD(pressure
unit< std::ratio< 101325 >, pascals >	UNIT_ADD (pressure, pounds_per_square_inch, pounds_per_square_inch, psi, compound_unit< force::pounds, inverse< squared< length::inch > > >) using namespace pressure
	UNIT_ADD_WITH_METRIC_PREFIXES (conductance, siemens, siemens, S, unit< std::ratio< 1 >, units::category::conductance_unit >) using namespace conductance
	UNIT_ADD (angular_acceleration, radians_per_second_squared, radians_per_second_squared, rad_per_s_sq, unit< std::ratio< 1 >, units::category::angular_acceleration_unit >) UNIT_ADD(angular_acceleration
compound_unit< angle::degrees, inverse< squared< time::seconds > > >	UNIT_ADD (angular_acceleration, turns_per_second_squared, turns_per_second_squared, tr_per_s_sq, compound_unit< angle::turns, inverse< squared< time::seconds > > >) UNIT_ADD(angular_acceleration
compound_unit< angle::degrees, inverse< squared< time::seconds > > > compound_unit< angle::turns, inverse< squared< time::minutes > > >	UNIT_ADD (angular_acceleration, revolutions_per_minute_per_second, revolutions_per_minute_per_second, rev_per_m_per_s, compound_unit< angle::turns, compound_unit< inverse< time::minutes >, inverse< time::seconds > > >) using namespace angular_acceleration
	UNIT_ADD_WITH_METRIC_PREFIXES (magnetic_flux, weber, webers, Wb, unit< std::ratio< 1 >, units::category::magnetic_flux_unit >) UNIT_ADD(magnetic_flux
	UNIT_ADD (density, kilograms_per_cubic_meter, kilograms_per_cubic_meter, kg_per_cu_m, unit< std::ratio< 1 >, units::category::density_unit >) UNIT_ADD(density
compound_unit< mass::grams, inverse< volume::milliliter > >	UNIT_ADD (density, kilograms_per_liter, kilograms_per_liter, kg_per_L, unit< std::ratio< 1 >, compound_unit< mass::grams, inverse< volume::milliliter > > >) UNIT_ADD(density
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > >	UNIT_ADD (density, ounces_per_cubic_inch, ounces_per_cubic_inch, oz_per_cu_in, compound_unit< mass::ounces, inverse< volume::cubic_inch > >) UNIT_ADD(density
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > >	UNIT_ADD (density, pounds_per_cubic_foot, pounds_per_cubic_foot, lb_per_cu_ft, compound_unit< mass::pounds, inverse< volume::cubic_foot > >) UNIT_ADD(density
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > >	UNIT_ADD (density, pounds_per_gallon, pounds_per_gallon, lb_per_gal, compound_unit< mass::pounds, inverse< volume::gallon > >) UNIT_ADD(density
	UNIT_ADD_WITH_METRIC_PREFIXES (time, second, seconds, s, unit< std::ratio< 1 >, units::category::time_unit >) UNIT_ADD(time
unit< std::ratio< 31557600 >, seconds >	UNIT_ADD (time, gregorian_year, gregorian_years, a_g, unit< std::ratio< 31556952 >, seconds >) using namespace time
	UNIT_ADD (substance, mole, moles, mol, unit< std::ratio< 1 >, units::category::substance_unit >) using namespace substance
	UNIT_ADD_WITH_METRIC_PREFIXES (charge, coulomb, coulombs, C, unit< std::ratio< 1 >, units::category::charge_unit >) UNIT_ADD_WITH_METRIC_PREFIXES(charge
	UNIT_ADD_WITH_METRIC_PREFIXES (luminous_intensity, candela, candelas, cd, unit< std::ratio< 1 >, units::category::luminous_intensity_unit >) using namespace luminous_intensity
	UNIT_ADD_WITH_METRIC_PREFIXES (frequency, hertz, hertz, Hz, unit< std::ratio< 1 >, units::category::frequency_unit >) using namespace frequency
	UNIT_ADD (velocity, meters_per_second, meters_per_second, mps, unit< std::ratio< 1 >, units::category::velocity_unit >) UNIT_ADD(velocity
compound_unit< length::feet, inverse< time::seconds > >	UNIT_ADD (velocity, miles_per_hour, miles_per_hour, mph, compound_unit< length::miles, inverse< time::hour > >) UNIT_ADD(velocity
compound_unit< length::feet, inverse< time::seconds > > compound_unit< length::kilometers, inverse< time::hour > >	UNIT_ADD (velocity, knot, knots, kts, compound_unit< length::nauticalMiles, inverse< time::hour > >) using namespace velocity
	UNIT_ADD_WITH_METRIC_PREFIXES (inductance, henry, henries, H, unit< std::ratio< 1 >, units::category::inductance_unit >) using namespace inductance
	UNIT_ADD_WITH_METRIC_PREFIXES (magnetic_field_strength, tesla, teslas, Te, unit< std::ratio< 1 >, units::category::magnetic_field_strength_unit >) UNIT_ADD(magnetic_field_strength
	UNIT_ADD_WITH_METRIC_PREFIXES (impedance, ohm, ohms, Ohm, unit< std::ratio< 1 >, units::category::impedance_unit >) using namespace impedance
	UNIT_ADD_WITH_METRIC_PREFIXES (illuminance, lux, luxes, lx, unit< std::ratio< 1 >, units::category::illuminance_unit >) UNIT_ADD(illuminance
compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > >	UNIT_ADD (illuminance, lumens_per_square_inch, lumens_per_square_inch, lm_per_in_sq, compound_unit< luminous_flux::lumen, inverse< squared< length::inch > > >) UNIT_ADD(illuminance
	UNIT_ADD (concentration, ppm, parts_per_million, ppm, unit< std::ratio< 1, 1000000 >, units::category::scalar_unit >) UNIT_ADD(concentration
unit< std::ratio< 1, 1000 >, parts_per_million >	UNIT_ADD (concentration, ppt, parts_per_trillion, ppt, unit< std::ratio< 1, 1000 >, parts_per_billion >) UNIT_ADD(concentration
	UNIT_ADD_WITH_METRIC_PREFIXES (mass, gram, grams, g, unit< std::ratio< 1, 1000 >, units::category::mass_unit >) UNIT_ADD(mass
unit< std::ratio< 45359237, 100000000 >, kilograms >	UNIT_ADD (mass, slug, slugs, slug, unit< std::ratio< 145939029, 10000000 >, kilograms >) using namespace mass
	UNIT_ADD_WITH_METRIC_PREFIXES (power, watt, watts, W, unit< std::ratio< 1 >, units::category::power_unit >) using namespace power
	UNIT_ADD_WITH_METRIC_PREFIXES (current, ampere, amperes, A, unit< std::ratio< 1 >, units::category::current_unit >) using namespace current
	UNIT_ADD_WITH_METRIC_PREFIXES (angle, radian, radians, rad, unit< std::ratio< 1 >, units::category::angle_unit >) UNIT_ADD(angle
unit< std::ratio< 1, 180 >, radians, std::ratio< 1 > >	UNIT_ADD (angle, arcsecond, arcseconds, arcsec, unit< std::ratio< 1, 60 >, arcminutes >) using namespace angle
	UNIT_ADD_WITH_METRIC_PREFIXES (length, meter, meters, m, unit< std::ratio< 1 >, units::category::length_unit >) UNIT_ADD(length
unit< std::ratio< 1852 >, meters >	UNIT_ADD (length, astronicalUnit, astronicalUnits, au, unit< std::ratio< 149597870700 >, meters >) UNIT_ADD(length
unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters >	UNIT_ADD (length, parsec, parsecs, pc, unit< std::ratio< 648000 >, astronicalUnits, std::ratio<-1 > >) UNIT_ADD(length
unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters > unit< std::ratio< 1, 10 >, nanometers >	UNIT_ADD (length, nauticalLeague, nauticalLeagues, nl, unit< std::ratio< 3 >, nauticalMiles >) using namespace length
	UNIT_ADD (moment_of_inertia, kilogram_square_meter, kilogram_square_meters, kg_sq_m, compound_unit< mass::kilograms, area::square_meters >) using namespace moment_of_inertia
	UNIT_ADD (torque, newton_meter, newton_meters, Nm, unit< std::ratio< 1 >, units::energy::joule >) UNIT_ADD(torque
compound_unit< length::foot, force::pounds >	UNIT_ADD (torque, foot_poundal, foot_poundals, ftpdl, compound_unit< length::foot, force::poundal >) UNIT_ADD(torque
compound_unit< length::foot, force::pounds > compound_unit< length::inch, force::pounds >	UNIT_ADD (torque, meter_kilogram, meter_kilograms, mkgf, compound_unit< length::meter, force::kiloponds >) using namespace torque
	UNIT_ADD (angular_jerk, radians_per_second_cubed, radians_per_second_cubed, rad_per_s_cu, unit< std::ratio< 1 >, units::category::angular_jerk_unit >) UNIT_ADD(angular_jerk
compound_unit< angle::degrees, inverse< cubed< time::seconds > > >	UNIT_ADD (angular_jerk, turns_per_second_cubed, turns_per_second_cubed, tr_per_s_cu, compound_unit< angle::turns, inverse< cubed< time::seconds > > >) using namespace angular_jerk
	UNIT_ADD_WITH_METRIC_PREFIXES (voltage, volt, volts, V, unit< std::ratio< 1 >, units::category::voltage_unit >) UNIT_ADD(voltage
	UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES (data_transfer_rate, bytes_per_second, bytes_per_second, Bps, unit< std::ratio< 1 >, units::category::data_transfer_rate_unit >) UNIT_ADD(data_transfer_rate
unit< std::ratio< 1000 >, petabytes_per_second >	UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES (data_transfer_rate, bits_per_second, bits_per_second, bps, unit< std::ratio< 1, 8 >, bytes_per_second >) UNIT_ADD(data_transfer_rate
template<typename T >
constexpr const char *	name (const T &)
template<typename T >
constexpr const char *	abbreviation (const T &)
template<class UnitFrom , class UnitTo , typename T = UNIT_LIB_DEFAULT_TYPE>
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, 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 , 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 , 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 UNIT_LIB_DEFAULT_TYPE 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 UNIT_LIB_DEFAULT_TYPE rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator!= (const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator!= (const Units &lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator>= (const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator>= (const Units &lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator> (const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator> (const Units &lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator<= (const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator<= (const Units &lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator< (const UNIT_LIB_DEFAULT_TYPE lhs, const Units &rhs) noexcept
template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr bool	operator< (const Units &lhs, const UNIT_LIB_DEFAULT_TYPE rhs) noexcept
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.
	UNIT_ADD_WITH_METRIC_PREFIXES (luminous_flux, lumen, lumens, lm, unit< std::ratio< 1 >, units::category::luminous_flux_unit >) using namespace luminous_flux
	UNIT_ADD (temperature, kelvin, kelvin, K, unit< std::ratio< 1 >, units::category::temperature_unit >) UNIT_ADD(temperature
unit< std::ratio< 1 >, kelvin, std::ratio< 0 >, std::ratio< 27315, 100 > >	UNIT_ADD (temperature, fahrenheit, fahrenheit, degF, unit< std::ratio< 5, 9 >, celsius, std::ratio< 0 >, std::ratio<-160, 9 > >) using namespace temperature
	UNIT_ADD_WITH_METRIC_PREFIXES (radiation, becquerel, becquerels, Bq, unit< std::ratio< 1 >, units::frequency::hertz >) UNIT_ADD_WITH_METRIC_PREFIXES(radiation
compound_unit< energy::joules, inverse< mass::kilogram > >	UNIT_ADD_WITH_METRIC_PREFIXES (radiation, sievert, sieverts, Sv, unit< std::ratio< 1 >, grays >) UNIT_ADD(radiation
	UNIT_ADD_WITH_METRIC_PREFIXES (solid_angle, steradian, steradians, sr, unit< std::ratio< 1 >, units::category::solid_angle_unit >) UNIT_ADD(solid_angle
squared< angle::degrees >	UNIT_ADD (solid_angle, spat, spats, sp, unit< std::ratio< 4 >, steradians, std::ratio< 1 > >) using namespace solid_angle
	UNIT_ADD_WITH_METRIC_PREFIXES (force, newton, newtons, N, unit< std::ratio< 1 >, units::category::force_unit >) UNIT_ADD(force
compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > >	UNIT_ADD (force, kilopond, kiloponds, kp, compound_unit< acceleration::standard_gravity, mass::kilograms >) UNIT_ADD(force
	UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES (data, byte, bytes, B, unit< std::ratio< 1 >, units::category::data_unit >) UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES(data
	UNIT_ADD_WITH_METRIC_PREFIXES (capacitance, farad, farads, F, unit< std::ratio< 1 >, units::category::capacitance_unit >) using namespace capacitance
	UNIT_ADD (volume, cubic_meter, cubic_meters, cu_m, unit< std::ratio< 1 >, units::category::volume_unit >) UNIT_ADD(volume
cubed< length::millimeter >	UNIT_ADD (volume, cubic_kilometer, cubic_kilometers, cu_km, cubed< length::kilometer >) UNIT_ADD_WITH_METRIC_PREFIXES(volume
cubed< length::millimeter > cubed< deci< length::meter > >	UNIT_ADD (volume, bushel, bushels, bu, unit< std::ratio< 215042, 100 >, cubic_inches >) UNIT_ADD(volume
	UNIT_ADD_WITH_METRIC_PREFIXES (energy, joule, joules, J, unit< std::ratio< 1 >, units::category::energy_unit >) UNIT_ADD_WITH_METRIC_PREFIXES(energy
unit< std::ratio< 4184, 1000 >, joules >	UNIT_ADD (energy, kilowatt_hour, kilowatt_hours, kWh, unit< std::ratio< 36, 10 >, megajoules >) UNIT_ADD(energy
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours >	UNIT_ADD (energy, british_thermal_unit, british_thermal_units, BTU, unit< std::ratio< 105505585262, 100000000 >, joules >) UNIT_ADD(energy
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules >	UNIT_ADD (energy, british_thermal_unit_59, british_thermal_units_59, BTU59, unit< std::ratio< 1054804, 1000 >, joules >) UNIT_ADD(energy
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > unit< std::ratio< 100000 >, british_thermal_units_59 >	UNIT_ADD (energy, foot_pound, foot_pounds, ftlbf, unit< std::ratio< 13558179483314004, 10000000000000000 >, joules >) using namespace energy
	UNIT_ADD (area, square_meter, square_meters, sq_m, unit< std::ratio< 1 >, units::category::area_unit >) UNIT_ADD(area
	UNIT_ADD (angular_velocity, radians_per_second, radians_per_second, rad_per_s, unit< std::ratio< 1 >, units::category::angular_velocity_unit >) UNIT_ADD(angular_velocity
compound_unit< angle::degrees, inverse< time::seconds > >	UNIT_ADD (angular_velocity, turns_per_second, turns_per_second, tps, compound_unit< angle::turns, inverse< time::seconds > >) UNIT_ADD(angular_velocity
compound_unit< angle::degrees, inverse< time::seconds > > unit< std::ratio< 2, 60 >, radians_per_second, std::ratio< 1 > >	UNIT_ADD (angular_velocity, milliarcseconds_per_year, milliarcseconds_per_year, mas_per_yr, compound_unit< angle::milliarcseconds, inverse< time::year > >) using namespace angular_velocity

Variables
	feet_per_second_squared
	fps_sq
	atmosphere
	atmospheres
	atm
	degrees_per_second_squared
	deg_per_s_sq
compound_unit< angle::degrees, inverse< squared< time::seconds > > >	revolutions_per_minute_squared
compound_unit< angle::degrees, inverse< squared< time::seconds > > >	rev_per_m_sq
	maxwell
	maxwells
	Mx
	grams_per_milliliter
	g_per_mL
compound_unit< mass::grams, inverse< volume::milliliter > >	ounces_per_cubic_foot
compound_unit< mass::grams, inverse< volume::milliliter > >	oz_per_cu_ft
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > >	ounces_per_gallon
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > >	oz_per_gal
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > >	pounds_per_cubic_inch
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > >	lb_per_cu_in
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > >	slugs_per_cubic_foot
compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > >	slug_per_cu_ft
	julian_year
	julian_years
	a_j
	ampere_hour
	ampere_hours
	Ah
	feet_per_second
	fps
compound_unit< length::feet, inverse< time::seconds > >	kilometers_per_hour
compound_unit< length::feet, inverse< time::seconds > >	kph
	gauss
	G
	footcandle
	footcandles
	fc
compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > >	phot
compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > >	phots
compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > >	ph
	ppb
	parts_per_billion
unit< std::ratio< 1, 1000 >, parts_per_million >	percent
unit< std::ratio< 1, 1000 >, parts_per_million >	pct
	pound
	pounds
	lb
	degree
	degrees
	deg
	nauticalMile
	nauticalMiles
	nmi
unit< std::ratio< 1852 >, meters >	lightyear
unit< std::ratio< 1852 >, meters >	lightyears
unit< std::ratio< 1852 >, meters >	ly
unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters >	angstrom
unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters >	angstroms
	foot_pound
	foot_pounds
	ftlb
compound_unit< length::foot, force::pounds >	inch_pound
compound_unit< length::foot, force::pounds >	inch_pounds
compound_unit< length::foot, force::pounds >	inlb
	degrees_per_second_cubed
	deg_per_s_cu
	statvolt
	statvolts
	statV
	exabytes_per_second
	EBps
unit< std::ratio< 1000 >, petabytes_per_second >	exabits_per_second
unit< std::ratio< 1000 >, petabytes_per_second >	Ebps
	celsius
	degC
	gray
	grays
	Gy
compound_unit< energy::joules, inverse< mass::kilogram > >	rutherford
compound_unit< energy::joules, inverse< mass::kilogram > >	rutherfords
compound_unit< energy::joules, inverse< mass::kilogram > >	rd
	degree_squared
	degrees_squared
	sq_deg
	lbf
compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > >	poundal
compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > >	poundals
compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > >	pdl
	bit
	bits
	b
	cubic_millimeter
	cubic_millimeters
	cu_mm
cubed< length::millimeter >	liter
cubed< length::millimeter >	liters
cubed< length::millimeter >	L
cubed< length::millimeter > cubed< deci< length::meter > >	tablespoon
cubed< length::millimeter > cubed< deci< length::meter > >	tablespoons
cubed< length::millimeter > cubed< deci< length::meter > >	tbsp
	calorie
	calories
	cal
unit< std::ratio< 4184, 1000 >, joules >	watt_hour
unit< std::ratio< 4184, 1000 >, joules >	watt_hours
unit< std::ratio< 4184, 1000 >, joules >	Wh
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours >	british_thermal_unit_iso
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours >	british_thermal_units_iso
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours >	BTU_iso
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules >	therm
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules >	therms
unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules >	thm
	square_kilometer
	square_kilometers
	sq_km
	degrees_per_second
	deg_per_s
compound_unit< angle::degrees, inverse< time::seconds > >	revolutions_per_minute
compound_unit< angle::degrees, inverse< time::seconds > >	rpm

Detailed Description

Unit Conversion Library namespace.

Typedef Documentation

curvature_t

using units::curvature_t

Initial value:

 units::unit_t<
    units::compound_unit<units::radians, units::inverse<units::meters>>>

Function Documentation

abbreviation()

template<typename T >

const char * units::abbreviation ( const T & )

constexpr

name()

template<typename T >

const char * units::name ( const T & )

constexpr

operator!=() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator!= ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator!=() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator!= ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

operator*() [1/5]

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>

UnitTypeLhs units::operator* ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs )

constexprnoexcept

Multiplication by a dimensionless unit for unit_t types with a linear scale.

operator*() [2/5]

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>

UnitTypeRhs units::operator* ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs )

constexprnoexcept

Multiplication by a dimensionless unit for unit_t types with a linear scale.

operator*() [3/5]

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

constexprnoexcept

Multiplication type for convertible unit_t types with a linear scale.

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

Returns:

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

Returns:

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

operator*() [4/5]

template<class UnitTypeLhs , typename T , std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeLhs >::value, int > = 0>

UnitTypeLhs units::operator* ( const UnitTypeLhs & lhs, T rhs )

constexprnoexcept

Multiplication by a scalar for unit_t types with a linear scale.

operator*() [5/5]

template<class UnitTypeRhs , typename T , std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeRhs >::value, int > = 0>

UnitTypeRhs units::operator* ( T lhs, const UnitTypeRhs & rhs )

constexprnoexcept

Multiplication by a scalar for unit_t types with a linear scale.

operator*=()

template<class Units , typename T , template< typename > class NonLinearScale, typename RhsType >

unit_t< Units, T, NonLinearScale > & units::operator*= ( unit_t< Units, T, NonLinearScale > & lhs, const RhsType & rhs )

constexprnoexcept

operator+() [1/8]

template<class UnitTypeRhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>

UnitTypeRhs units::operator+ ( const dimensionless::dB_t & lhs, const UnitTypeRhs & rhs )

inlineconstexprnoexcept

Addition between unit_t types with a decibel_scale and dimensionless dB units.

operator+() [2/8]

template<typename T , std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>

dimensionless::scalar_t units::operator+ ( const dimensionless::scalar_t & lhs, T rhs )

constexprnoexcept

Addition operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.

operator+() [3/8]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > units::operator+ ( const unit_t< Units, T, NonLinearScale > & u )

constexprnoexcept

operator+() [4/8]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t<!traits::is_same_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>

int units::operator+ ( const UnitTypeLhs & , const UnitTypeRhs &  )

inlineconstexprnoexcept

operator+() [5/8]

template<class UnitTypeLhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs >::value &&!traits::is_dimensionless_unit< UnitTypeLhs >::value, int > = 0>

UnitTypeLhs units::operator+ ( const UnitTypeLhs & lhs, const dimensionless::dB_t & rhs )

inlineconstexprnoexcept

Addition between unit_t types with a decibel_scale and dimensionless dB units.

operator+() [6/8]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t< traits::has_linear_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>

UnitTypeLhs units::operator+ ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs )

constexprnoexcept

Addition operator for unit_t types with a linear_scale.

operator+() [7/8]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t< traits::has_decibel_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>>, typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type, decibel_scale>

inlineconstexprnoexcept

Addition for convertible unit_t types with a decibel_scale.

operator+() [8/8]

template<typename T , std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>

dimensionless::scalar_t units::operator+ ( T lhs, const dimensionless::scalar_t & rhs )

constexprnoexcept

Addition operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.

operator++() [1/2]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > & units::operator++ ( unit_t< Units, T, NonLinearScale > & u )

constexprnoexcept

operator++() [2/2]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > units::operator++ ( unit_t< Units, T, NonLinearScale > & u, int  )

constexprnoexcept

operator+=()

template<class Units , typename T , template< typename > class NonLinearScale, typename RhsType >

unit_t< Units, T, NonLinearScale > & units::operator+= ( unit_t< Units, T, NonLinearScale > & lhs, const RhsType & rhs )

constexprnoexcept

operator-() [1/7]

template<class UnitTypeRhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>

auto units::operator- ( const dimensionless::dB_t & lhs, const UnitTypeRhs & rhs ) -> unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>, typename units::traits::unit_t_traits<UnitTypeRhs>::underlying_type, decibel_scale>

inlineconstexprnoexcept

Subtraction between unit_t types with a decibel_scale and dimensionless dB units.

operator-() [2/7]

template<typename T , std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>

dimensionless::scalar_t units::operator- ( const dimensionless::scalar_t & lhs, T rhs )

constexprnoexcept

Subtraction operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.

operator-() [3/7]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > units::operator- ( const unit_t< Units, T, NonLinearScale > & u )

constexprnoexcept

operator-() [4/7]

template<class UnitTypeLhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs >::value &&!traits::is_dimensionless_unit< UnitTypeLhs >::value, int > = 0>

UnitTypeLhs units::operator- ( const UnitTypeLhs & lhs, const dimensionless::dB_t & rhs )

inlineconstexprnoexcept

Subtraction between unit_t types with a decibel_scale and dimensionless dB units.

operator-() [5/7]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t< traits::has_linear_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>

UnitTypeLhs units::operator- ( const UnitTypeLhs & lhs, const UnitTypeRhs & rhs )

constexprnoexcept

Subtraction operator for unit_t types with a linear_scale.

operator-() [6/7]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs, 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>>, typename units::traits::unit_t_traits<UnitTypeLhs>::underlying_type, decibel_scale>

inlineconstexprnoexcept

Subtraction for convertible unit_t types with a decibel_scale.

operator-() [7/7]

template<typename T , std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>

dimensionless::scalar_t units::operator- ( T lhs, const dimensionless::scalar_t & rhs )

constexprnoexcept

Subtraction operator for scalar unit_t types with a linear_scale. Scalar types can be implicitly converted to built-in types.

operator--() [1/2]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > & units::operator-- ( unit_t< Units, T, NonLinearScale > & u )

constexprnoexcept

operator--() [2/2]

template<class Units , typename T , template< typename > class NonLinearScale>

unit_t< Units, T, NonLinearScale > units::operator-- ( unit_t< Units, T, NonLinearScale > & u, int  )

constexprnoexcept

operator-=()

template<class Units , typename T , template< typename > class NonLinearScale, typename RhsType >

unit_t< Units, T, NonLinearScale > & units::operator-= ( unit_t< Units, T, NonLinearScale > & lhs, const RhsType & rhs )

constexprnoexcept

operator/() [1/5]

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 )

constexprnoexcept

Division for convertible unit_t types with a linear scale.

Returns:

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

operator/() [2/5]

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>

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

constexprnoexcept

Division by a dimensionless unit for unit_t types with a linear scale.

operator/() [3/5]

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

constexprnoexcept

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

Division of a dimensionless unit by a unit_t type with a linear scale.

Returns:

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

operator/() [4/5]

template<class UnitTypeLhs , typename T , std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeLhs >::value, int > = 0>

UnitTypeLhs units::operator/ ( const UnitTypeLhs & lhs, T rhs )

constexprnoexcept

Division by a scalar for unit_t types with a linear scale.

operator/() [5/5]

template<class UnitTypeRhs , typename T , std::enable_if_t< std::is_arithmetic< T >::value &&traits::has_linear_scale< UnitTypeRhs >::value, int > = 0>

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

constexprnoexcept

Division of a scalar by a unit_t type with a linear scale.

operator/=()

template<class Units , typename T , template< typename > class NonLinearScale, typename RhsType >

unit_t< Units, T, NonLinearScale > & units::operator/= ( unit_t< Units, T, NonLinearScale > & lhs, const RhsType & rhs )

constexprnoexcept

operator<() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator< ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator<() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator< ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

operator<=() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator<= ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator<=() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator<= ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

operator==() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator== ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator==() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator== ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

operator>() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator> ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator>() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator> ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

operator>=() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator>= ( const UNIT_LIB_DEFAULT_TYPE lhs, const Units & rhs )

constexprnoexcept

operator>=() [2/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>

bool units::operator>= ( const Units & lhs, const UNIT_LIB_DEFAULT_TYPE rhs )

constexprnoexcept

UNIT_ADD() [1/45]

units::UNIT_ADD	(	acceleration	,
		meters_per_second_squared	,
		meters_per_second_squared	,
		mps_sq	,
		unit< std::ratio< 1 >, units::category::acceleration_unit >	)

UNIT_ADD() [2/45]

compound_unit< length::feet, inverse< squared< time::seconds > > > units::UNIT_ADD	(	acceleration	,
		standard_gravity	,
		standard_gravity	,
		SG	,
		unit< std::ratio< 980665, 100000 >, meters_per_second_squared >	)

UNIT_ADD() [3/45]

unit< std::ratio< 1, 180 >, radians, std::ratio< 1 > > units::UNIT_ADD	(	angle	,
		arcsecond	,
		arcseconds	,
		arcsec	,
		unit< std::ratio< 1, 60 >, arcminutes >	)

UNIT_ADD() [4/45]

units::UNIT_ADD	(	angular_acceleration	,
		radians_per_second_squared	,
		radians_per_second_squared	,
		rad_per_s_sq	,
		unit< std::ratio< 1 >, units::category::angular_acceleration_unit >	)

UNIT_ADD() [5/45]

compound_unit< angle::degrees, inverse< squared< time::seconds > > > compound_unit< angle::turns, inverse< squared< time::minutes > > > units::UNIT_ADD	(	angular_acceleration	,
		revolutions_per_minute_per_second	,
		revolutions_per_minute_per_second	,
		rev_per_m_per_s	,
		compound_unit< angle::turns, compound_unit< inverse< time::minutes >, inverse< time::seconds > > >	)

UNIT_ADD() [6/45]

compound_unit< angle::degrees, inverse< squared< time::seconds > > > units::UNIT_ADD	(	angular_acceleration	,
		turns_per_second_squared	,
		turns_per_second_squared	,
		tr_per_s_sq	,
		compound_unit< angle::turns, inverse< squared< time::seconds > > >	)

UNIT_ADD() [7/45]

units::UNIT_ADD	(	angular_jerk	,
		radians_per_second_cubed	,
		radians_per_second_cubed	,
		rad_per_s_cu	,
		unit< std::ratio< 1 >, units::category::angular_jerk_unit >	)

UNIT_ADD() [8/45]

compound_unit< angle::degrees, inverse< cubed< time::seconds > > > units::UNIT_ADD	(	angular_jerk	,
		turns_per_second_cubed	,
		turns_per_second_cubed	,
		tr_per_s_cu	,
		compound_unit< angle::turns, inverse< cubed< time::seconds > > >	)

UNIT_ADD() [9/45]

compound_unit< angle::degrees, inverse< time::seconds > > unit< std::ratio< 2, 60 >, radians_per_second, std::ratio< 1 > > units::UNIT_ADD	(	angular_velocity	,
		milliarcseconds_per_year	,
		milliarcseconds_per_year	,
		mas_per_yr	,
		compound_unit< angle::milliarcseconds, inverse< time::year > >	)

UNIT_ADD() [10/45]

units::UNIT_ADD	(	angular_velocity	,
		radians_per_second	,
		radians_per_second	,
		rad_per_s	,
		unit< std::ratio< 1 >, units::category::angular_velocity_unit >	)

UNIT_ADD() [11/45]

compound_unit< angle::degrees, inverse< time::seconds > > units::UNIT_ADD	(	angular_velocity	,
		turns_per_second	,
		turns_per_second	,
		tps	,
		compound_unit< angle::turns, inverse< time::seconds > >	)

UNIT_ADD() [12/45]

units::UNIT_ADD	(	area	,
		square_meter	,
		square_meters	,
		sq_m	,
		unit< std::ratio< 1 >, units::category::area_unit >	)

UNIT_ADD() [13/45]

units::UNIT_ADD	(	concentration	,
		ppm	,
		parts_per_million	,
		ppm	,
		unit< std::ratio< 1, 1000000 >, units::category::scalar_unit >	)

UNIT_ADD() [14/45]

unit< std::ratio< 1, 1000 >, parts_per_million > units::UNIT_ADD	(	concentration	,
		ppt	,
		parts_per_trillion	,
		ppt	,
		unit< std::ratio< 1, 1000 >, parts_per_billion >	)

UNIT_ADD() [15/45]

units::UNIT_ADD	(	density	,
		kilograms_per_cubic_meter	,
		kilograms_per_cubic_meter	,
		kg_per_cu_m	,
		unit< std::ratio< 1 >, units::category::density_unit >	)

UNIT_ADD() [16/45]

compound_unit< mass::grams, inverse< volume::milliliter > > units::UNIT_ADD	(	density	,
		kilograms_per_liter	,
		kilograms_per_liter	,
		kg_per_L	,
		unit< std::ratio< 1 >, compound_unit< mass::grams, inverse< volume::milliliter > > >	)

UNIT_ADD() [17/45]

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > units::UNIT_ADD	(	density	,
		ounces_per_cubic_inch	,
		ounces_per_cubic_inch	,
		oz_per_cu_in	,
		compound_unit< mass::ounces, inverse< volume::cubic_inch > >	)

UNIT_ADD() [18/45]

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > units::UNIT_ADD	(	density	,
		pounds_per_cubic_foot	,
		pounds_per_cubic_foot	,
		lb_per_cu_ft	,
		compound_unit< mass::pounds, inverse< volume::cubic_foot > >	)

UNIT_ADD() [19/45]

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > > units::UNIT_ADD	(	density	,
		pounds_per_gallon	,
		pounds_per_gallon	,
		lb_per_gal	,
		compound_unit< mass::pounds, inverse< volume::gallon > >	)

UNIT_ADD() [20/45]

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > units::UNIT_ADD	(	energy	,
		british_thermal_unit	,
		british_thermal_units	,
		BTU	,
		unit< std::ratio< 105505585262, 100000000 >, joules >	)

UNIT_ADD() [21/45]

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > units::UNIT_ADD	(	energy	,
		british_thermal_unit_59	,
		british_thermal_units_59	,
		BTU59	,
		unit< std::ratio< 1054804, 1000 >, joules >	)

UNIT_ADD() [22/45]

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > unit< std::ratio< 100000 >, british_thermal_units_59 > units::UNIT_ADD	(	energy	,
		foot_pound	,
		foot_pounds	,
		ftlbf	,
		unit< std::ratio< 13558179483314004, 10000000000000000 >, joules >	)

UNIT_ADD() [23/45]

unit< std::ratio< 4184, 1000 >, joules > units::UNIT_ADD	(	energy	,
		kilowatt_hour	,
		kilowatt_hours	,
		kWh	,
		unit< std::ratio< 36, 10 >, megajoules >	)

UNIT_ADD() [24/45]

compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > > units::UNIT_ADD	(	force	,
		kilopond	,
		kiloponds	,
		kp	,
		compound_unit< acceleration::standard_gravity, mass::kilograms >	)

UNIT_ADD() [25/45]

compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > > units::UNIT_ADD	(	illuminance	,
		lumens_per_square_inch	,
		lumens_per_square_inch	,
		lm_per_in_sq	,
		compound_unit< luminous_flux::lumen, inverse< squared< length::inch > > >	)

UNIT_ADD() [26/45]

unit< std::ratio< 1852 >, meters > units::UNIT_ADD	(	length	,
		astronicalUnit	,
		astronicalUnits	,
		au	,
		unit< std::ratio< 149597870700 >, meters >	)

UNIT_ADD() [27/45]

unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters > unit< std::ratio< 1, 10 >, nanometers > units::UNIT_ADD	(	length	,
		nauticalLeague	,
		nauticalLeagues	,
		nl	,
		unit< std::ratio< 3 >, nauticalMiles >	)

UNIT_ADD() [28/45]

unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters > units::UNIT_ADD	(	length	,
		parsec	,
		parsecs	,
		pc	,
		unit< std::ratio< 648000 >, astronicalUnits, std::ratio<-1 > >	)

UNIT_ADD() [29/45]

unit< std::ratio< 45359237, 100000000 >, kilograms > units::UNIT_ADD	(	mass	,
		slug	,
		slugs	,
		slug	,
		unit< std::ratio< 145939029, 10000000 >, kilograms >	)

UNIT_ADD() [30/45]

units::UNIT_ADD	(	moment_of_inertia	,
		kilogram_square_meter	,
		kilogram_square_meters	,
		kg_sq_m	,
		compound_unit< mass::kilograms, area::square_meters >	)

UNIT_ADD() [31/45]

unit< std::ratio< 101325 >, pascals > units::UNIT_ADD	(	pressure	,
		pounds_per_square_inch	,
		pounds_per_square_inch	,
		psi	,
		compound_unit< force::pounds, inverse< squared< length::inch > > >	)

UNIT_ADD() [32/45]

squared< angle::degrees > units::UNIT_ADD	(	solid_angle	,
		spat	,
		spats	,
		sp	,
		unit< std::ratio< 4 >, steradians, std::ratio< 1 > >	)

UNIT_ADD() [33/45]

units::UNIT_ADD	(	substance	,
		mole	,
		moles	,
		mol	,
		unit< std::ratio< 1 >, units::category::substance_unit >	)

UNIT_ADD() [34/45]

unit< std::ratio< 1 >, kelvin, std::ratio< 0 >, std::ratio< 27315, 100 > > units::UNIT_ADD	(	temperature	,
		fahrenheit	,
		fahrenheit	,
		degF	,
		unit< std::ratio< 5, 9 >, celsius, std::ratio< 0 >, std::ratio<-160, 9 > >	)

UNIT_ADD() [35/45]

units::UNIT_ADD	(	temperature	,
		kelvin	,
		kelvin	,
		K	,
		unit< std::ratio< 1 >, units::category::temperature_unit >	)

UNIT_ADD() [36/45]

unit< std::ratio< 31557600 >, seconds > units::UNIT_ADD	(	time	,
		gregorian_year	,
		gregorian_years	,
		a_g	,
		unit< std::ratio< 31556952 >, seconds >	)

UNIT_ADD() [37/45]

compound_unit< length::foot, force::pounds > units::UNIT_ADD	(	torque	,
		foot_poundal	,
		foot_poundals	,
		ftpdl	,
		compound_unit< length::foot, force::poundal >	)

UNIT_ADD() [38/45]

compound_unit< length::foot, force::pounds > compound_unit< length::inch, force::pounds > units::UNIT_ADD	(	torque	,
		meter_kilogram	,
		meter_kilograms	,
		mkgf	,
		compound_unit< length::meter, force::kiloponds >	)

UNIT_ADD() [39/45]

units::UNIT_ADD	(	torque	,
		newton_meter	,
		newton_meters	,
		Nm	,
		unit< std::ratio< 1 >, units::energy::joule >	)

UNIT_ADD() [40/45]

compound_unit< length::feet, inverse< time::seconds > > compound_unit< length::kilometers, inverse< time::hour > > units::UNIT_ADD	(	velocity	,
		knot	,
		knots	,
		kts	,
		compound_unit< length::nauticalMiles, inverse< time::hour > >	)

UNIT_ADD() [41/45]

units::UNIT_ADD	(	velocity	,
		meters_per_second	,
		meters_per_second	,
		mps	,
		unit< std::ratio< 1 >, units::category::velocity_unit >	)

UNIT_ADD() [42/45]

compound_unit< length::feet, inverse< time::seconds > > units::UNIT_ADD	(	velocity	,
		miles_per_hour	,
		miles_per_hour	,
		mph	,
		compound_unit< length::miles, inverse< time::hour > >	)

UNIT_ADD() [43/45]

cubed< length::millimeter > cubed< deci< length::meter > > units::UNIT_ADD	(	volume	,
		bushel	,
		bushels	,
		bu	,
		unit< std::ratio< 215042, 100 >, cubic_inches >	)

UNIT_ADD() [44/45]

cubed< length::millimeter > units::UNIT_ADD	(	volume	,
		cubic_kilometer	,
		cubic_kilometers	,
		cu_km	,
		cubed< length::kilometer >	)

UNIT_ADD() [45/45]

units::UNIT_ADD	(	volume	,
		cubic_meter	,
		cubic_meters	,
		cu_m	,
		unit< std::ratio< 1 >, units::category::volume_unit >	)

UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES() [1/3]

units::UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES	(	data	,
		byte	,
		bytes	,
		B	,
		unit< std::ratio< 1 >, units::category::data_unit >	)

UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES() [2/3]

unit< std::ratio< 1000 >, petabytes_per_second > units::UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES	(	data_transfer_rate	,
		bits_per_second	,
		bits_per_second	,
		bps	,
		unit< std::ratio< 1, 8 >, bytes_per_second >	)

UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES() [3/3]

units::UNIT_ADD_WITH_METRIC_AND_BINARY_PREFIXES	(	data_transfer_rate	,
		bytes_per_second	,
		bytes_per_second	,
		Bps	,
		unit< std::ratio< 1 >, units::category::data_transfer_rate_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [1/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	angle	,
		radian	,
		radians	,
		rad	,
		unit< std::ratio< 1 >, units::category::angle_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [2/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	capacitance	,
		farad	,
		farads	,
		F	,
		unit< std::ratio< 1 >, units::category::capacitance_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [3/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	charge	,
		coulomb	,
		coulombs	,
		C	,
		unit< std::ratio< 1 >, units::category::charge_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [4/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	conductance	,
		siemens	,
		siemens	,
		S	,
		unit< std::ratio< 1 >, units::category::conductance_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [5/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	current	,
		ampere	,
		amperes	,
		A	,
		unit< std::ratio< 1 >, units::category::current_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [6/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	energy	,
		joule	,
		joules	,
		J	,
		unit< std::ratio< 1 >, units::category::energy_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [7/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	force	,
		newton	,
		newtons	,
		N	,
		unit< std::ratio< 1 >, units::category::force_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [8/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	frequency	,
		hertz	,
		hertz	,
		Hz	,
		unit< std::ratio< 1 >, units::category::frequency_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [9/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	illuminance	,
		lux	,
		luxes	,
		lx	,
		unit< std::ratio< 1 >, units::category::illuminance_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [10/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	impedance	,
		ohm	,
		ohms	,
		Ohm	,
		unit< std::ratio< 1 >, units::category::impedance_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [11/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	inductance	,
		henry	,
		henries	,
		H	,
		unit< std::ratio< 1 >, units::category::inductance_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [12/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	length	,
		meter	,
		meters	,
		m	,
		unit< std::ratio< 1 >, units::category::length_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [13/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	luminous_flux	,
		lumen	,
		lumens	,
		lm	,
		unit< std::ratio< 1 >, units::category::luminous_flux_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [14/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	luminous_intensity	,
		candela	,
		candelas	,
		cd	,
		unit< std::ratio< 1 >, units::category::luminous_intensity_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [15/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	magnetic_field_strength	,
		tesla	,
		teslas	,
		Te	,
		unit< std::ratio< 1 >, units::category::magnetic_field_strength_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [16/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	magnetic_flux	,
		weber	,
		webers	,
		Wb	,
		unit< std::ratio< 1 >, units::category::magnetic_flux_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [17/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	mass	,
		gram	,
		grams	,
		g	,
		unit< std::ratio< 1, 1000 >, units::category::mass_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [18/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	power	,
		watt	,
		watts	,
		W	,
		unit< std::ratio< 1 >, units::category::power_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [19/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	pressure	,
		pascal	,
		pascals	,
		Pa	,
		unit< std::ratio< 1 >, units::category::pressure_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [20/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	radiation	,
		becquerel	,
		becquerels	,
		Bq	,
		unit< std::ratio< 1 >, units::frequency::hertz >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [21/24]

compound_unit< energy::joules, inverse< mass::kilogram > > units::UNIT_ADD_WITH_METRIC_PREFIXES	(	radiation	,
		sievert	,
		sieverts	,
		Sv	,
		unit< std::ratio< 1 >, grays >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [22/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	solid_angle	,
		steradian	,
		steradians	,
		sr	,
		unit< std::ratio< 1 >, units::category::solid_angle_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [23/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	time	,
		second	,
		seconds	,
		s	,
		unit< std::ratio< 1 >, units::category::time_unit >	)

UNIT_ADD_WITH_METRIC_PREFIXES() [24/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES	(	voltage	,
		volt	,
		volts	,
		V	,
		unit< std::ratio< 1 >, units::category::voltage_unit >	)

Variable Documentation

a_j

units::a_j

Ah

units::Ah

ampere_hour

units::ampere_hour

ampere_hours

units::ampere_hours

angstrom

unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters > units::angstrom

angstroms

unit< std::ratio< 1852 >, meters > unit< std::ratio< 9460730472580800 >, meters > units::angstroms

atm

units::atm

atmosphere

units::atmosphere

atmospheres

units::atmospheres

b

units::b

bit

units::bit

bits

units::bits

british_thermal_unit_iso

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > units::british_thermal_unit_iso

british_thermal_units_iso

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > units::british_thermal_units_iso

BTU_iso

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > units::BTU_iso

cal

units::cal

calorie

units::calorie

calories

units::calories

celsius

units::celsius

cu_mm

units::cu_mm

cubic_millimeter

units::cubic_millimeter

cubic_millimeters

units::cubic_millimeters

deg

units::deg

deg_per_s

units::deg_per_s

deg_per_s_cu

units::deg_per_s_cu

deg_per_s_sq

units::deg_per_s_sq

degC

units::degC

degree

units::degree

degree_squared

units::degree_squared

degrees

units::degrees

degrees_per_second

units::degrees_per_second

degrees_per_second_cubed

units::degrees_per_second_cubed

degrees_per_second_squared

units::degrees_per_second_squared

degrees_squared

units::degrees_squared

EBps

units::EBps

Ebps

unit< std::ratio< 1000 >, petabytes_per_second > units::Ebps

exabits_per_second

unit< std::ratio< 1000 >, petabytes_per_second > units::exabits_per_second

exabytes_per_second

units::exabytes_per_second

fc

units::fc

feet_per_second

units::feet_per_second

feet_per_second_squared

units::feet_per_second_squared

foot_pound

units::foot_pound

foot_pounds

units::foot_pounds

footcandle

units::footcandle

footcandles

units::footcandles

fps

units::fps

fps_sq

units::fps_sq

ftlb

units::ftlb

G

units::G

g_per_mL

units::g_per_mL

gauss

units::gauss

grams_per_milliliter

units::grams_per_milliliter

gray

units::gray

grays

units::grays

Gy

units::Gy

inch_pound

compound_unit< length::foot, force::pounds > units::inch_pound

inch_pounds

compound_unit< length::foot, force::pounds > units::inch_pounds

inlb

compound_unit< length::foot, force::pounds > units::inlb

julian_year

units::julian_year

julian_years

units::julian_years

kilometers_per_hour

compound_unit< length::feet, inverse< time::seconds > > units::kilometers_per_hour

kph

compound_unit< length::feet, inverse< time::seconds > > units::kph

L

cubed< length::millimeter > units::L

lb

units::lb

lb_per_cu_in

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > units::lb_per_cu_in

lbf

units::lbf

lightyear

unit< std::ratio< 1852 >, meters > units::lightyear

lightyears

unit< std::ratio< 1852 >, meters > units::lightyears

liter

cubed< length::millimeter > units::liter

liters

cubed< length::millimeter > units::liters

ly

unit< std::ratio< 1852 >, meters > units::ly

maxwell

units::maxwell

maxwells

units::maxwells

Mx

units::Mx

nauticalMile

units::nauticalMile

nauticalMiles

units::nauticalMiles

nmi

units::nmi

ounces_per_cubic_foot

compound_unit< mass::grams, inverse< volume::milliliter > > units::ounces_per_cubic_foot

ounces_per_gallon

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > units::ounces_per_gallon

oz_per_cu_ft

compound_unit< mass::grams, inverse< volume::milliliter > > units::oz_per_cu_ft

oz_per_gal

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > units::oz_per_gal

parts_per_billion

units::parts_per_billion

pct

unit< std::ratio< 1, 1000 >, parts_per_million > units::pct

pdl

compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > > units::pdl

percent

unit< std::ratio< 1, 1000 >, parts_per_million > units::percent

ph

compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > > units::ph

phot

compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > > units::phot

phots

compound_unit< luminous_flux::lumen, inverse< squared< length::foot > > > units::phots

pound

units::pound

poundal

compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > > units::poundal

poundals

compound_unit< mass::slug, length::foot, inverse< squared< time::seconds > > > units::poundals

pounds

units::pounds

pounds_per_cubic_inch

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > units::pounds_per_cubic_inch

ppb

units::ppb

rd

compound_unit< energy::joules, inverse< mass::kilogram > > units::rd

rev_per_m_sq

compound_unit< angle::degrees, inverse< squared< time::seconds > > > units::rev_per_m_sq

revolutions_per_minute

compound_unit< angle::degrees, inverse< time::seconds > > units::revolutions_per_minute

revolutions_per_minute_squared

compound_unit< angle::degrees, inverse< squared< time::seconds > > > units::revolutions_per_minute_squared

rpm

compound_unit< angle::degrees, inverse< time::seconds > > units::rpm

rutherford

compound_unit< energy::joules, inverse< mass::kilogram > > units::rutherford

rutherfords

compound_unit< energy::joules, inverse< mass::kilogram > > units::rutherfords

slug_per_cu_ft

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > > units::slug_per_cu_ft

slugs_per_cubic_foot

compound_unit< mass::grams, inverse< volume::milliliter > > compound_unit< mass::ounces, inverse< volume::cubic_foot > > compound_unit< mass::ounces, inverse< volume::gallon > > compound_unit< mass::pounds, inverse< volume::cubic_inch > > units::slugs_per_cubic_foot

sq_deg

units::sq_deg

sq_km

units::sq_km

square_kilometer

units::square_kilometer

square_kilometers

units::square_kilometers

statV

units::statV

statvolt

units::statvolt

statvolts

units::statvolts

tablespoon

cubed< length::millimeter > cubed< deci< length::meter > > units::tablespoon

tablespoons

cubed< length::millimeter > cubed< deci< length::meter > > units::tablespoons

tbsp

cubed< length::millimeter > cubed< deci< length::meter > > units::tbsp

therm

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > units::therm

therms

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > units::therms

thm

unit< std::ratio< 4184, 1000 >, joules > unit< std::ratio< 1, 1000 >, kilowatt_hours > unit< std::ratio< 1055056, 1000 >, joules > units::thm

watt_hour

unit< std::ratio< 4184, 1000 >, joules > units::watt_hour

watt_hours

unit< std::ratio< 4184, 1000 >, joules > units::watt_hours

Wh

unit< std::ratio< 4184, 1000 >, joules > units::Wh