WPILibC++ 2024.3.1
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

template<class U >
using inverse = typename units::detail::inverse_impl< U >::type
 represents the inverse unit type of class U. More...
 
template<class U >
using squared = typename units::detail::squared_impl< U >::type
 represents the unit type of class U squared More...
 
template<class U >
using cubed = typename units::detail::cubed_impl< U >::type
 represents the type of class U cubed. More...
 
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. More...
 
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. More...
 
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. More...
 
using curvature_t = units::unit_t< units::compound_unit< units::radians, units::inverse< units::meters > > >
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

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 (substance, mole, moles, mol, unit< std::ratio< 1 >, units::category::substance_unit >) using namespace substance
 
 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 (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 (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_WITH_METRIC_PREFIXES (charge, coulomb, coulombs, C, unit< std::ratio< 1 >, units::category::charge_unit >) UNIT_ADD_WITH_METRIC_PREFIXES(charge
 
 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 (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
 
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. More...
 
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. More...
 
template<class Units , typename T , template< typename > class NonLinearScale, typename RhsType >
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 >
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 >
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 >
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>
unit_t< Units, T, NonLinearScale > & operator++ (unit_t< Units, T, NonLinearScale > &u) noexcept
 
template<class Units , typename T , template< typename > class NonLinearScale>
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>
unit_t< Units, T, NonLinearScale > & operator-- (unit_t< Units, T, NonLinearScale > &u) noexcept
 
template<class Units , typename T , template< typename > class NonLinearScale>
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
 UNIT_ADD_WITH_METRIC_PREFIXES (conductance, siemens, siemens, S, unit< std::ratio< 1 >, units::category::conductance_unit >) using namespace conductance
 
 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 (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 (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 (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
 
 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 (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 (luminous_flux, lumen, lumens, lm, unit< std::ratio< 1 >, units::category::luminous_flux_unit >) using namespace luminous_flux
 
 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_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
 
 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_field_strength, tesla, teslas, Te, unit< std::ratio< 1 >, units::category::magnetic_field_strength_unit >) UNIT_ADD(magnetic_field_strength
 
 UNIT_ADD (area, square_meter, square_meters, sq_m, unit< std::ratio< 1 >, units::category::area_unit >) UNIT_ADD(area
 
 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 (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 (current, ampere, amperes, A, unit< std::ratio< 1 >, units::category::current_unit >) using namespace current
 
 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 (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 (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 (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 (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_WITH_METRIC_PREFIXES (voltage, volt, volts, V, unit< std::ratio< 1 >, units::category::voltage_unit >) UNIT_ADD(voltage
 
 UNIT_ADD_WITH_METRIC_PREFIXES (capacitance, farad, farads, F, unit< std::ratio< 1 >, units::category::capacitance_unit >) using namespace capacitance
 
 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 (inductance, henry, henries, H, unit< std::ratio< 1 >, units::category::inductance_unit >) using namespace inductance
 
 UNIT_ADD_WITH_METRIC_PREFIXES (frequency, hertz, hertz, Hz, unit< std::ratio< 1 >, units::category::frequency_unit >) using namespace frequency
 
 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_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 (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
 

Variables

 feet_per_second_squared
 
 fps_sq
 
 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
 
 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
 
 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
 
 pound
 
 pounds
 
 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
 
 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
 
 degrees_per_second_cubed
 
 deg_per_s_cu
 
 ppb
 
 parts_per_billion
 
unit< std::ratio< 1, 1000 >, parts_per_million > percent
 
unit< std::ratio< 1, 1000 >, parts_per_million > pct
 
 degrees_per_second
 
 deg_per_s
 
compound_unit< angle::degrees, inverse< time::seconds > > revolutions_per_minute
 
compound_unit< angle::degrees, inverse< time::seconds > > rpm
 
 bit
 
 bits
 
 b
 
 degree
 
 degrees
 
 deg
 
 exabytes_per_second
 
 EBps
 
unit< std::ratio< 1000 >, petabytes_per_second > exabits_per_second
 
unit< std::ratio< 1000 >, petabytes_per_second > Ebps
 
 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
 
 gauss
 
 G
 
 square_kilometer
 
 square_kilometers
 
 sq_km
 
 atmosphere
 
 atmospheres
 
 atm
 
 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
 
 lb
 
 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
 
 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
 
 statvolt
 
 statvolts
 
 statV
 
 maxwell
 
 maxwells
 
 Mx
 
 degree_squared
 
 degrees_squared
 
 sq_deg
 
 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
 

Detailed Description

Unit Conversion Library namespace.

Typedef Documentation

◆ curvature_t

using units::curvature_t = typedef units::unit_t< units::compound_unit<units::radians, units::inverse<units::meters> >>

Function Documentation

◆ abbreviation()

template<typename T >
constexpr const char * units::abbreviation ( const T &  )
inlineconstexpr

◆ name()

template<typename T >
constexpr const char * units::name ( const T &  )
inlineconstexpr

◆ operator!=() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr 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>>
constexpr 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>
constexpr UnitTypeLhs units::operator* ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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>
constexpr UnitTypeRhs units::operator* ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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>
constexpr auto units::operator* ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
) -> unit_t<compound_unit<squared<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type>>>
inlineconstexprnoexcept

Multiplication type for convertible unit_t types with a linear scale.

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.
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>
constexpr UnitTypeLhs units::operator* ( const UnitTypeLhs &  lhs,
rhs 
)
inlineconstexprnoexcept

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>
constexpr UnitTypeRhs units::operator* ( lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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

◆ operator+() [1/8]

template<class UnitTypeRhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>
constexpr UnitTypeRhs units::operator+ ( const dimensionless::dB_t lhs,
const UnitTypeRhs &  rhs 
)
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>
constexpr dimensionless::scalar_t units::operator+ ( const dimensionless::scalar_t lhs,
rhs 
)
inlineconstexprnoexcept

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>
constexpr unit_t< Units, T, NonLinearScale > units::operator+ ( const unit_t< Units, T, NonLinearScale > &  u)
inlineconstexprnoexcept

◆ operator+() [4/8]

template<class UnitTypeLhs , class UnitTypeRhs , std::enable_if_t<!traits::is_same_scale< UnitTypeLhs, UnitTypeRhs >::value, int > = 0>
constexpr int units::operator+ ( const UnitTypeLhs &  ,
const UnitTypeRhs &   
)
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>
constexpr 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>
constexpr UnitTypeLhs units::operator+ ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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>
constexpr 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>
constexpr dimensionless::scalar_t units::operator+ ( lhs,
const dimensionless::scalar_t rhs 
)
inlineconstexprnoexcept

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

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

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

◆ operator-() [1/7]

template<class UnitTypeRhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeRhs >::value &&!traits::is_dimensionless_unit< UnitTypeRhs >::value, int > = 0>
constexpr auto units::operator- ( const dimensionless::dB_t lhs,
const UnitTypeRhs &  rhs 
) -> 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>
constexpr dimensionless::scalar_t units::operator- ( const dimensionless::scalar_t lhs,
rhs 
)
inlineconstexprnoexcept

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>
constexpr unit_t< Units, T, NonLinearScale > units::operator- ( const unit_t< Units, T, NonLinearScale > &  u)
inlineconstexprnoexcept

◆ operator-() [4/7]

template<class UnitTypeLhs , std::enable_if_t< traits::has_decibel_scale< UnitTypeLhs >::value &&!traits::is_dimensionless_unit< UnitTypeLhs >::value, int > = 0>
constexpr UnitTypeLhs units::operator- ( const UnitTypeLhs &  lhs,
const dimensionless::dB_t rhs 
)
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>
constexpr UnitTypeLhs units::operator- ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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>
constexpr 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>
constexpr dimensionless::scalar_t units::operator- ( lhs,
const dimensionless::scalar_t rhs 
)
inlineconstexprnoexcept

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

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

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

◆ 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>
constexpr dimensionless::scalar_t units::operator/ ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

Division for convertible unit_t types with a linear scale.

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

◆ operator/() [2/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>
constexpr UnitTypeLhs units::operator/ ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
)
inlineconstexprnoexcept

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>
constexpr auto units::operator/ ( const UnitTypeLhs &  lhs,
const UnitTypeRhs &  rhs 
) -> unit_t<compound_unit<typename units::traits::unit_t_traits<UnitTypeLhs>::unit_type, inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>>
inlineconstexprnoexcept

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

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>
constexpr UnitTypeLhs units::operator/ ( const UnitTypeLhs &  lhs,
rhs 
)
inlineconstexprnoexcept

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>
constexpr auto units::operator/ ( lhs,
const UnitTypeRhs &  rhs 
) -> unit_t<inverse<typename units::traits::unit_t_traits<UnitTypeRhs>::unit_type>>
inlineconstexprnoexcept

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

◆ operator<() [1/2]

template<typename Units , class = std::enable_if_t<units::traits::is_dimensionless_unit<Units>::value>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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>>
constexpr 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  ,
,
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  ,
,
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  ,
,
unit< std::ratio< 1 >, units::category::capacitance_unit  
)

◆ UNIT_ADD_WITH_METRIC_PREFIXES() [3/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES ( charge  ,
coulomb  ,
coulombs  ,
,
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  ,
,
unit< std::ratio< 1 >, units::category::current_unit  
)

◆ UNIT_ADD_WITH_METRIC_PREFIXES() [6/24]

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

◆ UNIT_ADD_WITH_METRIC_PREFIXES() [7/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES ( force  ,
newton  ,
newtons  ,
,
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  ,
,
unit< std::ratio< 1 >, units::category::inductance_unit  
)

◆ UNIT_ADD_WITH_METRIC_PREFIXES() [12/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES ( length  ,
meter  ,
meters  ,
,
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  ,
,
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  ,
,
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  ,
,
unit< std::ratio< 1 >, units::category::time_unit  
)

◆ UNIT_ADD_WITH_METRIC_PREFIXES() [24/24]

units::UNIT_ADD_WITH_METRIC_PREFIXES ( voltage  ,
volt  ,
volts  ,
,
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