# Units Reference

Absolute units (points rather than vectors).

Operations between absolute units, and relative units like temperature differences.

A wrapper to represent absolute units (points rather than vectors). Intended originally for temperatures, this class implements operators for absolute units so that addition of a relative unit to an absolute unit results in another absolute unit : absolute<T> +/- T -> absolute<T> and subtraction of one absolute unit from another results in a relative unit : absolute<T> - absolute<T> -> T.

`absolute`< Y >
Y
BOOST_CONSTEXPR const value_type &
BOOST_CXX14_CONSTEXPR const this_type & `const value_type &`
BOOST_CXX14_CONSTEXPR const this_type & `const value_type &`
const value_type &
const this_type &
BOOST_CXX14_CONSTEXPR this_type & `const this_type &`
BOOST_CONSTEXPR `absolute`< Y > `const `absolute`< Y > &` `const Y &` add a relative value to an absolute one
BOOST_CONSTEXPR `absolute`< Y > `const Y &` `const `absolute`< Y > &` add a relative value to an absolute one
BOOST_CONSTEXPR `absolute`< Y > `const `absolute`< Y > &` `const Y &` subtract a relative value from an absolute one
BOOST_CONSTEXPR Y `const `absolute`< Y > &` `const `absolute`< Y > &` subtracting two absolutes gives a difference
BOOST_CONSTEXPR `quantity`< `absolute`< `unit`< D, S > >, T > `const T &` `const `absolute`< `unit`< D, S > > &` creates a quantity from an absolute unit and a raw value
BOOST_CONSTEXPR `quantity`< `absolute`< `unit`< D, S > >, T > `const `absolute`< `unit`< D, S > > &` `const T &` creates a quantity from an absolute unit and a raw value
std::basic_ostream< Char, Traits > & `std::basic_ostream< Char, Traits > &` `const `absolute`< Y > &` Print an absolute unit.

Macro to define the offset between two absolute units. Requires the value to be in the destination units e.g

    BOOST_UNITS_DEFINE_CONVERSION_OFFSET(celsius_base_unit, fahrenheit_base_unit, double, 32.0);

`BOOST_UNITS_DEFINE_CONVERSION_FACTOR` is also necessary to specify the conversion factor. Like `BOOST_UNITS_DEFINE_CONVERSION_FACTOR` this macro defines both forward and reverse conversions so defining, e.g., the conversion from celsius to fahrenheit as above will also define the inverse conversion from fahrenheit to celsius.

base dimensions (mass, length, time...).

base dimension definition registration.

long
ordinal< N >

Defines a base dimension. To define a dimension you need to provide the derived class (CRTP) and a unique integer.

    struct my_dimension : boost::units::base_dimension<my_dimension, 1> {};

It is designed so that you will get an error message if you try to use the same value in multiple definitions.
A convenience typedef. Equivalent to boost::units::derived_dimension<Derived,1>::type.
unspecified
Provided for mpl compatability.
Derived

base unit (meter, kg, sec...).

base unit definition registration.

long
ordinal< N >

Defines a base unit. To define a unit you need to provide the derived class (CRTP), a dimension list and a unique integer.

    struct my_unit : boost::units::base_unit<my_unit, length_dimension, 1> {};

It is designed so that you will get an error message if you try to use the same value in multiple definitions.
The dimensions of this base unit.
Dim
Provided for mpl compatability.
Derived
The unit corresponding to this base unit.
unspecified

Overloads of functions in <cmath> for quantities.

Only functions for which a dimensionally-correct result type can be determined are overloaded. All functions work with dimensionless quantities.

BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR bool `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR int `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `root_typeof_helper`< typename `add_typeof_helper`< typename `power_typeof_helper`< `quantity`< Unit, Y >, `static_rational`< 2 > >::type, typename `power_typeof_helper`< `quantity`< Unit, Y >, `static_rational`< 2 > >::type >::type, `static_rational`< 2 > >::type `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR int `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` ``quantity`< Unit, Y > *`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `Int *`
BOOST_CONSTEXPR `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &` `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &`

For non-dimensionless quantities, integral and rational powers and roots can be computed by `pow<Ex>` and `root<Rt>` respectively.

BOOST_CONSTEXPR `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &`
BOOST_CONSTEXPR `quantity`< Unit, Y > `const `quantity`< Unit, Y > &` `const Int &`
BOOST_CONSTEXPR `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &`
BOOST_CONSTEXPR `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &`
BOOST_CONSTEXPR `root_typeof_helper`< `quantity`< Unit, Y >, `static_rational`< 2 > >::type `const `quantity`< Unit, Y > &`
BOOST_CONSTEXPR `dimensionless_quantity`< si::system, Y >::type `const `quantity`< si::plane_angle, Y > &` cos of theta in radians
BOOST_CONSTEXPR `dimensionless_quantity`< si::system, Y >::type `const `quantity`< si::plane_angle, Y > &` sin of theta in radians
BOOST_CONSTEXPR `dimensionless_quantity`< si::system, Y >::type `const `quantity`< si::plane_angle, Y > &` tan of theta in radians
BOOST_CONSTEXPR `dimensionless_quantity`< System, Y >::type `const `quantity`< `unit`< plane_angle_dimension, System >, Y > &` cos of theta in other angular units
BOOST_CONSTEXPR `dimensionless_quantity`< System, Y >::type `const `quantity`< `unit`< plane_angle_dimension, System >, Y > &` sin of theta in other angular units
BOOST_CONSTEXPR `dimensionless_quantity`< System, Y >::type `const `quantity`< `unit`< plane_angle_dimension, System >, Y > &` tan of theta in other angular units
BOOST_CONSTEXPR `quantity`< `unit`< plane_angle_dimension, `homogeneous_system`< System > >, Y > `const `quantity`< `unit`< `dimensionless_type`, `homogeneous_system`< System > >, Y > &` acos of dimensionless quantity returning angle in same system
BOOST_CONSTEXPR `quantity`< angle::radian_base_unit::unit_type, Y > `const `quantity`< `unit`< `dimensionless_type`, heterogeneous_dimensionless_system >, Y > &` acos of dimensionless quantity returning angle in radians
BOOST_CONSTEXPR `quantity`< `unit`< plane_angle_dimension, `homogeneous_system`< System > >, Y > `const `quantity`< `unit`< `dimensionless_type`, `homogeneous_system`< System > >, Y > &` asin of dimensionless quantity returning angle in same system
BOOST_CONSTEXPR `quantity`< angle::radian_base_unit::unit_type, Y > `const `quantity`< `unit`< `dimensionless_type`, heterogeneous_dimensionless_system >, Y > &` asin of dimensionless quantity returning angle in radians
BOOST_CONSTEXPR `quantity`< `unit`< plane_angle_dimension, `homogeneous_system`< System > >, Y > `const `quantity`< `unit`< `dimensionless_type`, `homogeneous_system`< System > >, Y > &` atan of dimensionless quantity returning angle in same system
BOOST_CONSTEXPR `quantity`< angle::radian_base_unit::unit_type, Y > `const `quantity`< `unit`< `dimensionless_type`, heterogeneous_dimensionless_system >, Y > &` atan of dimensionless quantity returning angle in radians
BOOST_CONSTEXPR `quantity`< `unit`< plane_angle_dimension, `homogeneous_system`< System > >, Y > `const `quantity`< `unit`< Dimension, `homogeneous_system`< System > >, Y > &` `const `quantity`< `unit`< Dimension, `homogeneous_system`< System > >, Y > &` atan2 of `value_type` returning angle in radians
BOOST_CONSTEXPR `quantity`< angle::radian_base_unit::unit_type, Y > `const `quantity`< `unit`< Dimension, `heterogeneous_system`< System > >, Y > &` `const `quantity`< `unit`< Dimension, `heterogeneous_system`< System > >, Y > &` atan2 of `value_type` returning angle in radians

If defined will trigger a static assertion if quantity<Unit, T> is not layout compatible with T

If defined will disable a preprocessor check that the compiler is able to handle the library.

Enable checking to verify that a homogeneous system is actually capable of representing all the dimensions that it is used with. Off by default.

Template for defining conversions between quantities.

Template for defining conversions between quantities. This template should be specialized for every quantity that allows conversions. For example, if you have a two units called pair and dozen you would write

    namespace boost {
    namespace units {
    template<class T0, class T1>
    struct conversion_helper<quantity<dozen, T0>, quantity<pair, T1> >
    {
        static quantity<pair, T1> convert(const quantity<dozen, T0>& source)
        {
            return(quantity<pair, T1>::from_value(6 * source.value()));
        }
    };
    }
    }

In most cases, the predefined specializations for `unit` and `absolute` should be sufficient, so users should rarely need to use this.

BOOST_CONSTEXPR To `const From &`
unspecified `const FromUnit &` `const ToUnit &` Find the conversion factor between two units.

Defines the conversion factor from a base unit to any unit or to another base unit with the correct dimensions. Uses of this macro must appear at global scope. If the destination unit is a base unit or a unit that contains only one base unit which is raised to the first power (e.g. feet->meters) the reverse (meters->feet in this example) need not be defined explicitly.

Defines the conversion factor from a base unit to any other base unit with the same dimensions. Params should be a Boost.Preprocessor Seq of template parameters, such as (class T1)(class T2) All uses of must appear at global scope. The reverse conversion will be defined automatically. This macro is a little dangerous, because, unlike the non-template form, it will silently fail if either base unit is scaled. This is probably not an issue if both the source and destination types depend on the template parameters, but be aware that a generic conversion to kilograms is not going to work.

Specifies the default conversion to be applied when no direct conversion is available. Source is a base unit. Dest is any unit with the same dimensions.

Specifies the default conversion to be applied when no direct conversion is available. Params is a PP Sequence of template arguments. Source is a base unit. Dest is any unit with the same dimensions. The source must not be a scaled base unit.

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0

boost::units::dimensionless_type

dimensionless_type
long 0
A utility class for defining composite dimensions with integer powers.
unspecified

Handling of fundamental dimension/exponent pairs.

Dimension tag/exponent pair for a single fundamental dimension.

The dim class represents a single dimension tag/dimension exponent pair. That is, `dim<tag_type,value_type>` is a pair where `tag_type` represents the fundamental dimension being represented and `value_type` represents the exponent of that fundamental dimension as a ``static_rational``. `tag_type` must be a derived from a specialization of ``base_dimension``. Specialization of the following Boost.MPL metafunctions are provided - @c mpl::plus for two @c dims - @c mpl::minus for two @c dims - @c mpl::negate for a @c dim

These metafunctions all operate on the exponent, and require that the `dim` operands have the same base dimension tag. In addition, multiplication and division by ``static_rational`` is supported. - @c mpl::times for a @c static_rational and a @c dim in either order - @c mpl::divides for a @c static_rational and a @c dim in either order

These metafunctions likewise operate on the exponent only.

`dim`
unspecified
T
V

Core metaprogramming utilities for compile-time dimensional analysis.

Reduce dimension list to cardinal form. This algorithm collapses duplicate base dimension tags and sorts the resulting list by the tag ordinal value. Dimension lists that resolve to the same dimension are guaranteed to be

represented by an identical type.

The argument should be an MPL forward sequence containing instances of the `dim` template.

The result is also an MPL forward sequence. It also supports the following metafunctions to allow use as a dimension.

- `mpl::plus` is defined only on two equal dimensions and returns the argument unchanged.

- `mpl::minus` is defined only for two equal dimensions and returns the argument unchanged.

- `mpl::negate` will return its argument unchanged.

- `mpl::times` is defined for any dimensions and adds corresponding exponents.

- `mpl::divides` is defined for any dimensions and subtracts the exponents of the right had argument from the corresponding exponents of the left had argument. Missing base dimension tags are assumed to have an exponent of zero.

- ``static_power`` takes a dimension and a `static_rational` and multiplies all the exponents of the dimension by the `static_rational`.

- ``static_root`` takes a dimension and a `static_rational` and divides all the exponents of the dimension by the `static_rational`.

unspecified

Utility class to simplify construction of dimensionless quantities.

Utility class to simplify construction of dimensionless quantities.
`quantity`< typename `dimensionless_unit`< System >::type, Y >

Dimension lists in which all exponents resolve to zero reduce to `dimensionless_type`.

Dimension lists in which all exponents resolve to zero reduce to ``dimensionless_type``.
`dimensionless_type`
unspecified
mpl::long_< 0 >

Utility class to simplify construction of dimensionless units in a system.

Utility class to simplify construction of dimensionless units in a system.
`unit`< `dimensionless_type`, System >

Get the dimension of a unit, absolute unit and quantity.

absolute< Unit >
Get the dimension of an absolute unit.
`get_dimension`< Unit >::type
quantity< Unit
Y >
Get the dimension of a quantity.
`get_dimension`< Unit >::type
unit< Dim
System >
Get the dimension of a unit.
Dim

Get the system of a unit, absolute unit or quantity.

absolute< Unit >
Get the system of an absolute unit.
`get_system`< Unit >::type
quantity< Unit
Y >
Get the system of a quantity.
`get_system`< Unit >::type
unit< Dim
System >
Get the system of a unit.
System

A heterogeneous system is a sorted list of base unit/exponent pairs.

A system that can uniquely represent any unit which can be composed from a linearly independent set of base units. It is safe to rebind a unit with such a system to different dimensions.

Do not construct this template directly. Use `make_system` instead.

Raise a dimension list to a scalar power.
Take a scalar root of a dimension list.

Stream input and output for rationals, units and quantities.

Functions and manipulators for output and input of units and quantities. symbol and name format, and engineering and binary autoprefix. Serialization output is also supported.

void `Archive &` ``boost::units::unit`< Dim, System > &` `const unsigned int` Boost Serialization library support for units.
void `Archive &` ``boost::units::quantity`< Unit, Y > &` `const unsigned int` Boost Serialization library support for quantities.
= 0
= 1
default - reduces unit names to known symbols for both base and derived units.
= 2
output full unit names for base and derived units, for example "meter".
= 3
output only symbols for base units (but not derived units), for example "m".
= 3
output demangled typenames (useful only for diagnosis).
format of output of units, for example "m" or "meter".
= 0
= 4
No automatic prefix.
= 8
Scale and prefix with 10^3 multiples, 1234.5 m output as 1.2345 km.
= 12
Scale and prefix with 2^10 (1024) multiples, 1024 as 1 kb.
automatic scaling and prefix (controlled by value of quantity) a, if any,
std::string `const T &`
std::string integer_type `const `static_rational`< N > &` get string representation of integral-valued ``static_rational``.
std::string integer_type integer_type `const `static_rational`< N, D > &` get string representation of ``static_rational``.
std::basic_ostream< Char, Traits > & integer_type integer_type `std::basic_ostream< Char, Traits > &` `const `static_rational`< N, D > &` Write ``static_rational`` to `std::basic_ostream`.
long `std::ios_base &` `long` returns flags controlling output.
void `std::ios_base &` `long` `long` Set new flags controlling output format.
format_mode `std::ios_base &` returns flags controlling output format.
void `std::ios_base &` `format_mode` Set new flags controlling output format.
std::ios_base & `std::ios_base &` Set new flags for type_name output format.
std::ios_base & `std::ios_base &` set new flag for raw format output, for example "m".
std::ios_base & `std::ios_base &` set new format flag for symbol output, for example "m".
std::ios_base & `std::ios_base &` set new format for name output, for example "meter".
autoprefix_mode `std::ios_base &` get autoprefix flags for output.
void `std::ios_base &` `autoprefix_mode` Get format for output.
std::ios_base & `std::ios_base &` Clear autoprefix flags.
std::ios_base & `std::ios_base &` Set flag for engineering prefix, so 1234.5 m displays as "1.2345 km".
std::ios_base & `std::ios_base &` Set flag for binary prefix, so 1024 byte displays as "1 Kib".
double `const T &`

ADL customization point for automatic prefixing. Returns a non-negative value. Implemented as std::abs for built-in types.

std::string `const `unit`< Dimension, System > &`
std::string `const `unit`< Dimension, System > &`
std::string `const `unit`< Dimension, System > &`
std::basic_ostream< Char, Traits > & `std::basic_ostream< Char, Traits > &` `const `unit`< Dimension, System > &`

Print a `unit` as a list of base units and their exponents. for @c symbol_format outputs e.g. "m s^-1" or "J". for @c name_format outputs e.g. "meter second^-1" or "joule". for @c raw_format outputs e.g. "m s^-1" or "meter kilogram^2 second^-2". for @c typename_format outputs the typename itself (currently demangled only on GCC).

std::basic_ostream< Char, Traits > & `std::basic_ostream< Char, Traits > &` `const `quantity`< Unit, T > &` Print a `quantity`.

Prints the value followed by the unit. If the engineering_prefix, or binary_prefix is set, tries to scale the value appropriately. For example, it might print 12.345 km instead of 12345 m. (Note does not attempt to automatically scale scalars like double, float...)

Check that a type is a valid `dim`.

false_
Check that a type is a valid `dim`.
dim< T
V >
true_

Check that a type is a valid dimension list.

false_
Check that a type is a valid dimension list.
dimensionless_type
true_
list< Item
Next >
true_

Check if a unit or quantity is dimensionless.

false_
quantity< Unit
Y >
boost::units::is_dimensionless< Unit >
Check if a quantity is dimensionless.
unit< dimensionless_type
System >
true_
Check if a unit is dimensionless.

check that a type is a dimensionless quantity

boost::units::is_quantity_of_dimension< T, dimensionless_type >
Check that a type is a dimensionless quantity.

Check that a type is a dimensionless unit.

boost::units::is_unit_of_dimension< T, dimensionless_type >
Check that a type is a dimensionless unit.

Check that a type is a quantity.

false_
Check that a type is a quantity.
quantity< Unit
Y >
true_

Check that a type is a quantity of the specified dimension.

false_
Check that a type is a quantity of the specified dimension.
quantity< Unit
Y >
Dim
boost::units::is_unit_of_dimension< Unit, Dim >

Check that a type is a quantity in a specified system.

false_
Check that a type is a quantity in a specified system.
quantity< Unit
Y >
System
boost::units::is_unit_of_system< Unit, System >

Check that a type is a unit.

false_
Check that a type is a unit.
unit< Dim
System >
true_

Check that a type is a unit of the specified dimension.

false_
Check that a type is a unit of the specified dimension.
absolute< unit< Dim
System > >
Dim
true_
unit< Dim
System >
Dim
true_

Check that a type is a unit in a specified system.

false_
Check that a type is a unit in a specified system.
absolute< unit< Dim
System > >
System
true_
unit< Dim
System >
System
true_

Definitions to ease the usage of Boost.Units' quantity, unit, and absolute types in functors created with the Boost.Lambda library.

Torsten Maehne

2008-06-16

Boost.Lambda's return type deduction system is extented to make use of Boost.Units' typeof_helper trait classes for Boost.Units' quantity, absolute, and unit template classes. unary_arithmetic_action< minus_action >boost::units::quantity< Unit Y >

Partial specialization of return type trait for action -quantity<Unit, Y>.

`boost::units::unary_minus_typeof_helper`< `boost::units::quantity`< Unit, Y > >::type unary_arithmetic_action< minus_action >boost::units::unit< Dim System >

Partial specialization of return type trait for action -unit<Dim, System>.

`boost::units::unary_minus_typeof_helper`< `boost::units::unit`< Dim, System > >::type unary_arithmetic_action< plus_action >boost::units::quantity< Unit Y >

Partial specialization of return type trait for action +quantity<Unit, Y>.

`boost::units::unary_plus_typeof_helper`< `boost::units::quantity`< Unit, Y > >::type unary_arithmetic_action< plus_action >boost::units::unit< Dim System >

Partial specialization of return type trait for action +unit<Dim, System>.

`boost::units::unary_plus_typeof_helper`< `boost::units::unit`< Dim, System > >::type arithmetic_action< divide_action >boost::units::quantity< Unit X >X

Partial specialization of return type trait for action quantity<Unit, X> / X.

`boost::units::divide_typeof_helper`< `boost::units::quantity`< Unit, X >, X >::type arithmetic_action< divide_action >boost::units::quantity< Unit1 X >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action quantity<Unit1, X> / quantity<Unit2, Y>.

`boost::units::divide_typeof_helper`< `boost::units::quantity`< Unit1, X >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< divide_action >boost::units::quantity< Unit1 Y >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action quantity<Unit1, Y> / unit<Dim2, System2>.

`boost::units::divide_typeof_helper`< `boost::units::quantity`< Unit1, Y >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< divide_action >boost::units::unit< Dim System >Y

Partial specialization of return type trait for action unit<Dim, System> / Y.

`boost::units::divide_typeof_helper`< `boost::units::unit`< Dim, System >, Y >::type arithmetic_action< divide_action >boost::units::unit< Dim1 System1 >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action unit<Dim1, System1> / quantity<Unit2, Y>.

`boost::units::divide_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< divide_action >boost::units::unit< Dim1 System1 >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action unit<Dim1, System1> / unit<Dim2, System2>.

`boost::units::divide_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< divide_action >X boost::units::quantity< Unit X >

Partial specialization of return type trait for action X / quantity<Unit, X>.

`boost::units::divide_typeof_helper`< X, `boost::units::quantity`< Unit, X > >::type arithmetic_action< divide_action >Y boost::units::unit< Dim System >

Partial specialization of return type trait for action Y / unit<Dim, System>.

`boost::units::divide_typeof_helper`< Y, `boost::units::unit`< Dim, System > >::type arithmetic_action< minus_action >boost::units::absolute< Y >boost::units::absolute< Y >

Partial specialization of return type trait for action absolute<Y> - absolute<Y>.

Y arithmetic_action< minus_action >boost::units::absolute< Y >Y

Partial specialization of return type trait for action absolute<Y> - Y.

`boost::units::absolute`< Y > arithmetic_action< minus_action >boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System)X >Y

Partial specialization of return type trait for action quantity<dimensionless, X> - Y.

`boost::units::subtract_typeof_helper`< `boost::units::quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y >::type arithmetic_action< minus_action >boost::units::quantity< Unit1 X >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action quantity<Unit1, X> - quantity<Unit2, Y>.

`boost::units::subtract_typeof_helper`< `boost::units::quantity`< Unit1, X >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< minus_action >boost::units::unit< Dim1 System1 >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action unit<Dim1, System1> - unit<Dim2, System2>.

`boost::units::subtract_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< minus_action >X boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System)Y >

Partial specialization of return type trait for action X - quantity<dimensionless, Y>.

`boost::units::subtract_typeof_helper`< X, `boost::units::quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y > >::type arithmetic_action< multiply_action >boost::units::absolute< boost::units::unit< D S > >T

Partial specialization of return type trait for action absolute<unit<D, S> > * T.

`boost::units::quantity`< `boost::units::absolute`< `boost::units::unit`< D, S > >, T > arithmetic_action< multiply_action >boost::units::quantity< Unit X >X

Partial specialization of return type trait for action quantity<Unit, X> * X.

`boost::units::multiply_typeof_helper`< `boost::units::quantity`< Unit, X >, X >::type arithmetic_action< multiply_action >boost::units::quantity< Unit1 X >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action quantity<Unit1, X> * quantity<Unit2, Y>.

`boost::units::multiply_typeof_helper`< `boost::units::quantity`< Unit1, X >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< multiply_action >boost::units::quantity< Unit1 Y >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action quantity<Unit1, Y> * unit<Dim2, System2>.

`boost::units::multiply_typeof_helper`< `boost::units::quantity`< Unit1, Y >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< multiply_action >boost::units::unit< Dim System >Y

Partial specialization of return type trait for action unit<Dim, System> * Y.

`boost::units::multiply_typeof_helper`< `boost::units::unit`< Dim, System >, Y >::type arithmetic_action< multiply_action >boost::units::unit< Dim1 System1 >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action unit<Dim1, System1> * quantity<Unit2, Y>.

`boost::units::multiply_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< multiply_action >boost::units::unit< Dim1 System1 >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action unit<Dim1, System1> * unit<Dim2, System2>.

`boost::units::multiply_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< multiply_action >T boost::units::absolute< boost::units::unit< D S > >

Partial specialization of return type trait for action T * absolute<unit<D, S> >.

`boost::units::quantity`< `boost::units::absolute`< `boost::units::unit`< D, S > >, T > arithmetic_action< multiply_action >X boost::units::quantity< Unit X >

Partial specialization of return type trait for action X * quantity<Unit, X>.

`boost::units::multiply_typeof_helper`< X, `boost::units::quantity`< Unit, X > >::type arithmetic_action< multiply_action >Y boost::units::unit< Dim System >

Partial specialization of return type trait for action Y * unit<Dim, System>.

`boost::units::multiply_typeof_helper`< Y, `boost::units::unit`< Dim, System > >::type arithmetic_action< plus_action >boost::units::absolute< Y >Y

Partial specialization of return type trait for action absolute<Y> + Y.

`boost::units::absolute`< Y > arithmetic_action< plus_action >boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System)X >Y

Partial specialization of return type trait for action quantity<dimensionless, X> + Y.

`boost::units::add_typeof_helper`< `boost::units::quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y >::type arithmetic_action< plus_action >boost::units::quantity< Unit1 X >boost::units::quantity< Unit2 Y >

Partial specialization of return type trait for action quantity<Unit1, X> + quantity<Unit2, Y>.

`boost::units::add_typeof_helper`< `boost::units::quantity`< Unit1, X >, `boost::units::quantity`< Unit2, Y > >::type arithmetic_action< plus_action >boost::units::unit< Dim1 System1 >boost::units::unit< Dim2 System2 >

Partial specialization of return type trait for action unit<Dim1, System1> + unit<Dim2, System2>.

`boost::units::add_typeof_helper`< `boost::units::unit`< Dim1, System1 >, `boost::units::unit`< Dim2, System2 > >::type arithmetic_action< plus_action >X boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System)Y >

Partial specialization of return type trait for action X + quantity<dimensionless, Y>.

`boost::units::add_typeof_helper`< X, `boost::units::quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y > >::type arithmetic_action< plus_action >Y boost::units::absolute< Y >

Partial specialization of return type trait for action Y + absolute<Y>.

`boost::units::absolute`< Y > boost::lambda::lambda_functor< Arg >boost::units::unit< Dim System >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::divide_action >, tuple< boost::lambda::lambda_functor< Arg >, typename boost::lambda::const_copy_argument< const `boost::units::unit`< Dim, System > >::type > > > boost::units::unit< Dim System >boost::lambda::lambda_functor< Arg >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::divide_action >, tuple< typename boost::lambda::const_copy_argument< const `boost::units::unit`< Dim, System > >::type, boost::lambda::lambda_functor< Arg > > > > boost::lambda::lambda_functor< Arg >boost::units::absolute< boost::units::unit< Dim System > >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::multiply_action >, tuple< boost::lambda::lambda_functor< Arg >, typename boost::lambda::const_copy_argument< const `boost::units::absolute`< `boost::units::unit`< Dim, System > > >::type > > > boost::lambda::lambda_functor< Arg >boost::units::unit< Dim System >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::multiply_action >, tuple< boost::lambda::lambda_functor< Arg >, typename boost::lambda::const_copy_argument< const `boost::units::unit`< Dim, System > >::type > > > boost::units::absolute< boost::units::unit< Dim System > >boost::lambda::lambda_functor< Arg >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::multiply_action >, tuple< typename boost::lambda::const_copy_argument< const `boost::units::absolute`< `boost::units::unit`< Dim, System > > >::type, boost::lambda::lambda_functor< Arg > > > > boost::units::unit< Dim System >boost::lambda::lambda_functor< Arg >boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action< boost::lambda::multiply_action >, tuple< typename boost::lambda::const_copy_argument< const `boost::units::unit`< Dim, System > >::type, boost::lambda::lambda_functor< Arg > > > > `const `multiply_typeof_helper`< `boost::units::unit`< Dim, System >, boost::lambda::lambda_functor< Arg > >::type `const `boost::units::unit`< Dim, System > &``const boost::lambda::lambda_functor< Arg > &`

Disambiguating overload for action unit<Dim, System> * lambda_functor<Arg> based on <boost/lambda/detail/operators.hpp>.

` `const `divide_typeof_helper`< `boost::units::unit`< Dim, System >, boost::lambda::lambda_functor< Arg > >::type `const `boost::units::unit`< Dim, System > &``const boost::lambda::lambda_functor< Arg > &`

Disambiguating overload for action unit<Dim, System> / lambda_functor<Arg> based on <boost/lambda/detail/operators.hpp>.

` `const `multiply_typeof_helper`< boost::lambda::lambda_functor< Arg >, `boost::units::unit`< Dim, System > >::type `const boost::lambda::lambda_functor< Arg > &``const `boost::units::unit`< Dim, System > &`

Disambiguating overload for action lambda_functor<Arg> * unit<Dim, System> based on <boost/lambda/detail/operators.hpp>.

` `const `divide_typeof_helper`< boost::lambda::lambda_functor< Arg >, `boost::units::unit`< Dim, System > >::type `const boost::lambda::lambda_functor< Arg > &``const `boost::units::unit`< Dim, System > &`

Disambiguating overload for action lambda_functor<Arg> / unit<Dim, System> based on <boost/lambda/detail/operators.hpp>.

` `const `multiply_typeof_helper`< boost::lambda::lambda_functor< Arg >, `boost::units::absolute`< `boost::units::unit`< Dim, System > > >::type `const boost::lambda::lambda_functor< Arg > &``const `boost::units::absolute`< `boost::units::unit`< Dim, System > > &`

Disambiguating overload for action lambda_functor<Arg> * absolute<unit<Dim, System> > based on <boost/lambda/detail/operators.hpp>.

` `const `multiply_typeof_helper`< `boost::units::absolute`< `boost::units::unit`< Dim, System > >, boost::lambda::lambda_functor< Arg > >::type `const `boost::units::absolute`< `boost::units::unit`< Dim, System > > &``const boost::lambda::lambda_functor< Arg > &`

Disambiguating overload for action absolute<unit<Dim, System> > * lambda_functor<Arg> based on <boost/lambda/detail/operators.hpp>.

`

specialize std::numeric_limits for units.

::boost::units::quantity< Unit
T >
::`boost::units::quantity`< Unit, T >
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR int
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR bool
BOOST_STATIC_CONSTEXPR float_denorm_style
BOOST_STATIC_CONSTEXPR float_round_style
BOOST_CONSTEXPR quantity_type()
BOOST_CONSTEXPR quantity_type()
BOOST_CONSTEXPR quantity_type()
BOOST_CONSTEXPR quantity_type
BOOST_CONSTEXPR quantity_type
BOOST_CONSTEXPR quantity_type
BOOST_CONSTEXPR quantity_type
BOOST_CONSTEXPR quantity_type
BOOST_CONSTEXPR quantity_type
`make_scaled_unit`< typename `reduce_unit`< Unit >::type, Scale >::type
unit< Dimension
heterogeneous_system< heterogeneous_system_impl< UnitList
Dimension
OldScale > > >
Scale
`unit`< Dimension, `heterogeneous_system`< `heterogeneous_system_impl`< UnitList, Dimension, typename mpl::times< OldScale, list< scale_list_dim< Scale >, `dimensionless_type` > >::type > > >
long
unit< Dimension
heterogeneous_system< heterogeneous_system_impl< UnitList
Dimension
OldScale > > >
scale< Base
static_rational< 0 > >
`unit`< Dimension, `heterogeneous_system`< `heterogeneous_system_impl`< UnitList, Dimension, OldScale > > >

Metafunction returning a homogeneous system that can represent any combination of the base units.

Metafunction make_system returning a homogeneous system that can represent any combination of the base units. There must be no way to represent any of the base units in terms of the others. make_system<foot_base_unit, meter_base_unit>::type is not allowed, for example.

...

Metafunction returning a homogeneous system that can represent any combination of the base units. There must be no way to represent any of the base units in terms of the others. make_system<foot_base_unit, meter_base_unit>::type is not allowed, for example.

unspecified

Compile time operators and typeof helper classes.

These operators declare the compile-time operators needed to support dimensional analysis algebra. They require the use of Boost.Typeof, emulation or native. Typeof helper classes define result type for heterogeneous operators on value types. These must be defined through specialization for powers and roots.

typedef `(typeof_::make< X >()+typeof_::make< Y >())`
typedef `(typeof_::make< X >()/typeof_::make< Y >())`
typedef `(typeof_::make< X >() *typeof_::make< Y >())`

A helper used by `pow` to raise a runtime object to a compile time known exponent. This template is intended to be specialized. All specializations must conform to the interface shown here. `Exponent` will be either the exponent passed to `pow` or `static_rational<N>` for and integer argument, N.

specifies the result type
unspecified
BOOST_CONSTEXPR type `const BaseType &` Carries out the runtime calculation.

A helper used by `root` to take a root of a runtime object using a compile time known index. This template is intended to be specialized. All specializations must conform to the interface shown here. `Index` will be either the type passed to `pow` or `static_rational<N>` for and integer argument, N.

specifies the result type
unspecified
BOOST_CONSTEXPR type `const Radicand &` Carries out the runtime calculation.
typedef `(typeof_::make< X >() -typeof_::make< Y >())`
typedef `(-typeof_::make< X >())`
typedef `(+typeof_::make< X >())`

Raise values to exponents known at compile-time.

BOOST_CONSTEXPR `power_typeof_helper`< Y, Rat >::type `const Y &` raise a value to a ``static_rational`` power.
BOOST_CONSTEXPR `power_typeof_helper`< Y, `static_rational`< N > >::type long `const Y &` raise a value to an integer power.
BOOST_CONSTEXPR `root_typeof_helper`< Y, Rat >::type `const Y &` take the ``static_rational`` root of a value.
BOOST_CONSTEXPR `root_typeof_helper`< Y, `static_rational`< N > >::type long `const Y &` take the integer root of a value.
quantity< unit< Dim
System >
X >
quantity< unit< Dim
System >
Y >
`add_typeof_helper`< X, Y >::type
`unit`< Dim, System >
`quantity`< unit_type, value_type >
quantity< unit< Dim1
System1 >
X >
quantity< unit< Dim2
System2 >
Y >

for sun CC we need to invoke SFINAE at the top level, otherwise it will silently return int.

class declaration
`quantity`< Unit, Y >
Y
Unit
unspecified
BOOST_CONSTEXPR const value_type & constant accessor to value

can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type

BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit2, YY > &` can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit2, YY > &`
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit2, YY > &`
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit2, YY > &` can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const value_type &` can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const value_type &`
unspecified_null_pointer_constant_type
const this_type &
BOOST_CXX14_CONSTEXPR this_type & `const this_type &`
const `quantity`< Unit, YY > &
unspecified
0
implicit conversion between value types is allowed if allowed for value types themselves
const `quantity`< Unit, YY > &
unspecified
0
implicit conversion between value types is not allowed if not allowed for value types themselves
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit, YY > &` implicit assignment between value types is allowed if allowed for value types themselves
const `quantity`< Unit2, YY > &
unspecified
0
explicit conversion between different unit systems is allowed if implicit conversion is disallowed
const `quantity`< Unit2, YY > &
unspecified
0
implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< Unit2, YY > &` implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible
BOOST_CONSTEXPR this_type `const value_type &` Construct quantity directly from `value_type` (potentially dangerous).
const value_type &
int
BOOST_UNITS_DIMENSIONLESS_UNIT(System)
Y

Specialization for dimensionless quantities. Implicit conversions between unit systems are allowed because all dimensionless quantities are equivalent. Implicit construction and assignment from and conversion to `value_type` is also allowed.

`quantity`< `unit`< `dimensionless_type`, System >, Y >
Y
System
`dimensionless_type`
`unit`< dimension_type, system_type >
BOOST_CONSTEXPR implicit conversion to `value_type` is allowed
BOOST_CONSTEXPR const value_type & constant accessor to value

can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type

BOOST_CXX14_CONSTEXPR this_type & `const this_type &` can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const this_type &` can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const value_type &` can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
BOOST_CXX14_CONSTEXPR this_type & `const value_type &`
value_type
construction from raw `value_type` is allowed
const this_type &
BOOST_CXX14_CONSTEXPR this_type & `const this_type &`
const `quantity`< `unit`< dimension_type, system_type >, YY > &
unspecified
0
implicit conversion between value types is allowed if allowed for value types themselves
const `quantity`< `unit`< dimension_type, system_type >, YY > &
unspecified
0
implicit conversion between value types is not allowed if not allowed for value types themselves
BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< `unit`< dimension_type, system_type >, YY > &` implicit assignment between value types is allowed if allowed for value types themselves
const `quantity`< `unit`< `dimensionless_type`, System2 >, Y2 > &
unspecified
0
unspecified
0
unspecified
0
implicit conversion between different unit systems is allowed
const `quantity`< `unit`< `dimensionless_type`, System2 >, Y2 > &
unspecified
0
unspecified
0
unspecified
0
implicit conversion between different unit systems is allowed
const `quantity`< `unit`< `dimensionless_type`, System2 >, Y2 > &
unspecified
0

conversion between different unit systems is explicit when the units are not equivalent.

BOOST_CXX14_CONSTEXPR this_type & `const `quantity`< BOOST_UNITS_DIMENSIONLESS_UNIT(System2), Y > &` implicit assignment between different unit systems is allowed
BOOST_CONSTEXPR this_type `const value_type &` Construct quantity directly from `value_type`.
quantity< unit< Dim
System >
X >
quantity< unit< Dim
System >
Y >
`subtract_typeof_helper`< X, Y >::type
`unit`< Dim, System >
`quantity`< unit_type, value_type >
quantity< unit< Dim1
System1 >
X >
quantity< unit< Dim2
System2 >
Y >
BOOST_CONSTEXPR X `Y &` quantity_cast provides mutating access to underlying quantity value_type
BOOST_CONSTEXPR X `const Y &`
void ``quantity`< Unit, Y > &` ``quantity`< Unit, Y > &` swap quantities
BOOST_CONSTEXPR `divide_typeof_helper`< `unit`< Dim, System >, Y >::type `const `unit`< Dim, System > &` `const Y &` runtime unit divided by scalar
BOOST_CONSTEXPR `multiply_typeof_helper`< Y, `unit`< Dim, System > >::type `const Y &` `const `unit`< Dim, System > &` runtime scalar times unit
BOOST_CONSTEXPR `divide_typeof_helper`< Y, `unit`< Dim, System > >::type `const Y &` `const `unit`< Dim, System > &` runtime scalar divided by unit
BOOST_CONSTEXPR `multiply_typeof_helper`< `quantity`< Unit, X >, X >::type `const `quantity`< Unit, X > &` `const X &` runtime quantity times scalar
BOOST_CONSTEXPR `multiply_typeof_helper`< X, `quantity`< Unit, X > >::type `const X &` `const `quantity`< Unit, X > &` runtime scalar times quantity
BOOST_CONSTEXPR `divide_typeof_helper`< `quantity`< Unit, X >, X >::type `const `quantity`< Unit, X > &` `const X &` runtime quantity divided by scalar
BOOST_CONSTEXPR `divide_typeof_helper`< X, `quantity`< Unit, X > >::type `const X &` `const `quantity`< Unit, X > &` runtime scalar divided by quantity
BOOST_CONSTEXPR `multiply_typeof_helper`< `unit`< Dim1, System1 >, `quantity`< Unit2, Y > >::type `const `unit`< Dim1, System1 > &` `const `quantity`< Unit2, Y > &` runtime unit times quantity
BOOST_CONSTEXPR `divide_typeof_helper`< `unit`< Dim1, System1 >, `quantity`< Unit2, Y > >::type `const `unit`< Dim1, System1 > &` `const `quantity`< Unit2, Y > &` runtime unit divided by quantity
BOOST_CONSTEXPR `multiply_typeof_helper`< `quantity`< Unit1, Y >, `unit`< Dim2, System2 > >::type `const `quantity`< Unit1, Y > &` `const `unit`< Dim2, System2 > &` runtime quantity times unit
BOOST_CONSTEXPR `divide_typeof_helper`< `quantity`< Unit1, Y >, `unit`< Dim2, System2 > >::type `const `quantity`< Unit1, Y > &` `const `unit`< Dim2, System2 > &` runtime quantity divided by unit
BOOST_CONSTEXPR `unary_plus_typeof_helper`< `quantity`< Unit, Y > >::type `const `quantity`< Unit, Y > &` runtime unary plus quantity
BOOST_CONSTEXPR `unary_minus_typeof_helper`< `quantity`< Unit, Y > >::type `const `quantity`< Unit, Y > &` runtime unary minus quantity
BOOST_CONSTEXPR `add_typeof_helper`< `quantity`< Unit1, X >, `quantity`< Unit2, Y > >::type `const `quantity`< Unit1, X > &` `const `quantity`< Unit2, Y > &` runtime quantity plus quantity
BOOST_CONSTEXPR `subtract_typeof_helper`< `quantity`< Unit1, X >, `quantity`< Unit2, Y > >::type `const `quantity`< Unit1, X > &` `const `quantity`< Unit2, Y > &` runtime quantity minus quantity
BOOST_CONSTEXPR `multiply_typeof_helper`< `quantity`< Unit1, X >, `quantity`< Unit2, Y > >::type `const `quantity`< Unit1, X > &` `const `quantity`< Unit2, Y > &` runtime quantity times quantity
BOOST_CONSTEXPR `divide_typeof_helper`< `quantity`< Unit1, X >, `quantity`< Unit2, Y > >::type `const `quantity`< Unit1, X > &` `const `quantity`< Unit2, Y > &` runtime quantity divided by quantity
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator==
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator!=
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator<
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator<=
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator>
BOOST_CONSTEXPR bool `const `quantity`< Unit, X > &` `const `quantity`< Unit, Y > &` runtime operator>=

Returns a unique type for every unit.

Returns a unique type for every unit.
unspecified

10^3 Engineering & 2^10 binary scaling factors for autoprefixing.

long

class representing a scaling factor such as 10^3 The exponent must be a static rational.

Exponent
double
BOOST_STATIC_CONSTEXPR long
BOOST_CONSTEXPR value_type
std::string long `const `scale`< Base, Exponent > &`
std::string long `const `scale`< Base, Exponent > &`
traits template for unit names.
std::string The full name of the unit (returns BaseUnit::name() by default)
std::string The symbol for the base unit (Returns BaseUnit::symbol() by default)

BaseUnit::symbol(), for example "m"

T

A system that can represent any possible combination of units at the expense of not preserving information about how it was created. Do not create specializations of this template directly. Instead use ``reduce_unit`` and `base_unit<...>::unit_type`.

`scaled_base_unit`
`scaled_base_unit_tag`
S
Scale
S::dimension_type
unspecified
std::string
std::string

A convenience macro that allows definition of static constants in headers in an ODR-safe way.

Compile-time rational numbers and operators.

integer_type
Compile time absolute value.
integer_type
integer_type
integer_type 1

This is an implementation of a compile time rational number, where `static_rational<N,D>` represents a rational number with numerator `N` and denominator `D`. Because of the potential for ambiguity arising from multiple equivalent values of ``static_rational`` (e.g. `static_rational<6,2>==static_rational<3>`), static rationals should always be accessed through `static_rational<N,D>::type`. Template specialization prevents instantiation of zero denominators (i.e. `static_rational<N,0>`). The following compile-time arithmetic operators are provided for `static_rational` variables only (no operators are defined between long and `static_rational`):

- `mpl::negate`

- `mpl::plus`

- `mpl::minus`

- `mpl::times`

- `mpl::divides`

Neither ``static_power`` nor ``static_root`` are defined for ``static_rational``. This is because template types may not be floating point values, while powers and roots of rational numbers can produce floating point values.

unspecified
static_rational<N,D> reduced by GCD
`static_rational`< Numerator, Denominator >
BOOST_STATIC_CONSTEXPR integer_type
BOOST_STATIC_CONSTEXPR integer_type
BOOST_CONSTEXPR integer_type
BOOST_CONSTEXPR integer_type
long
BOOST_CONSTEXPR `divide_typeof_helper`< T, T >::type integer_type integer_type `const `static_rational`< N, D > &` get decimal value of ``static_rational``
long
long
unit< Dim
System >
static_rational< N
D >
raise unit to a ``static_rational`` power
`unit`< typename `static_power`< Dim, `static_rational`< N, D > >::type, typename `static_power`< System, `static_rational`< N, D > >::type >
BOOST_CONSTEXPR type `const `unit`< Dim, System > &`
unit< Dim
System >
Returns a unique type for every unit.
unspecified
long
long
unit< Dim
System >
static_rational< N
D >
take the ``static_rational`` root of a unit
`unit`< typename `static_root`< Dim, `static_rational`< N, D > >::type, typename `static_root`< System, `static_rational`< N, D > >::type >
BOOST_CONSTEXPR type `const `unit`< Dim, System > &`
class representing a model-dependent unit with no associated value

(e.g. meters, Kelvin, feet, etc...)

`unit`< Dim, System >
`unit`< Dim, System >
Dim
System
const this_type &
BOOST_CXX14_CONSTEXPR this_type & `const this_type &`
BOOST_CONSTEXPR `unary_plus_typeof_helper`< `unit`< Dim, System > >::type `const `unit`< Dim, System > &` unit runtime unary plus
BOOST_CONSTEXPR `unary_minus_typeof_helper`< `unit`< Dim, System > >::type `const `unit`< Dim, System > &` unit runtime unary minus
BOOST_CONSTEXPR `add_typeof_helper`< `unit`< Dim1, System1 >, `unit`< Dim2, System2 > >::type `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` runtime add two units
BOOST_CONSTEXPR `subtract_typeof_helper`< `unit`< Dim1, System1 >, `unit`< Dim2, System2 > >::type `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` runtime subtract two units
BOOST_CONSTEXPR `multiply_typeof_helper`< `unit`< Dim1, System1 >, `unit`< Dim2, System2 > >::type `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` runtime multiply two units
BOOST_CONSTEXPR `divide_typeof_helper`< `unit`< Dim1, System1 >, `unit`< Dim2, System2 > >::type `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` runtime divide two units
BOOST_CONSTEXPR bool `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` unit runtime `operator==`
BOOST_CONSTEXPR bool `const `unit`< Dim1, System1 > &` `const `unit`< Dim2, System2 > &` unit runtime `operator!=`

Forward declarations of library components.

Forward declarations of units library - dimensions, systems, quantity and string components.