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 Yconst 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. 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. 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 boolconst quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > &const quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > &const quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > &const quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > &const quantity< Unit, Y > & BOOST_CONSTEXPR boolconst quantity< Unit, Y > &const quantity< Unit, Y > & BOOST_CONSTEXPR boolconst 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 intconst 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 > >::typeconst 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 intconst 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 > >::typeconst quantity< Unit, Y > & BOOST_CONSTEXPR dimensionless_quantity< si::system, Y >::typeconst quantity< si::plane_angle, Y > &cos of theta in radians BOOST_CONSTEXPR dimensionless_quantity< si::system, Y >::typeconst quantity< si::plane_angle, Y > &sin of theta in radians BOOST_CONSTEXPR dimensionless_quantity< si::system, Y >::typeconst quantity< si::plane_angle, Y > &tan of theta in radians BOOST_CONSTEXPR dimensionless_quantity< System, Y >::typeconst quantity< unit< plane_angle_dimension, System >, Y > &cos of theta in other angular units BOOST_CONSTEXPR dimensionless_quantity< System, Y >::typeconst quantity< unit< plane_angle_dimension, System >, Y > &sin of theta in other angular units BOOST_CONSTEXPR dimensionless_quantity< System, Y >::typeconst 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 Toconst From & unspecifiedconst 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.

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 berepresented 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< UnitY >Get the dimension of a quantity. get_dimension< Unit >::type unit< DimSystem >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< UnitY >Get the system of a quantity. get_system< Unit >::type unit< DimSystem >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. voidArchive &boost::units::unit< Dim, System > &const unsigned intBoost Serialization library support for units. voidArchive &boost::units::quantity< Unit, Y > &const unsigned intBoost Serialization library support for quantities. = 0= 1default - reduces unit names to known symbols for both base and derived units. = 2output full unit names for base and derived units, for example "meter". = 3output only symbols for base units (but not derived units), for example "m". = 3output demangled typenames (useful only for diagnosis). format of output of units, for example "m" or "meter". = 0= 4No automatic prefix. = 8Scale and prefix with 10^3 multiples, 1234.5 m output as 1.2345 km. = 12Scale and prefix with 2^10 (1024) multiples, 1024 as 1 kb. automatic scaling and prefix (controlled by value of quantity) a, if any, std::stringconst T & std::stringconst static_rational< N > &get string representation of integral-valued static_rational. std::stringconst static_rational< N, D > &get string representation of static_rational. std::basic_ostream< Char, Traits > &std::basic_ostream< Char, Traits > &const static_rational< N, D > &Write static_rational to std::basic_ostream. longstd::ios_base &longreturns flags controlling output. voidstd::ios_base &longlongSet new flags controlling output format. format_modestd::ios_base &returns flags controlling output format. voidstd::ios_base &format_modeSet 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_modestd::ios_base &get autoprefix flags for output. voidstd::ios_base &autoprefix_modeGet 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". doubleconst T &ADL customization point for automatic prefixing. Returns a non-negative value. Implemented as std::abs for built-in types. std::stringconst unit< Dimension, System > & std::stringconst unit< Dimension, System > & std::stringconst 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< TV >true_

Check that a type is a valid dimension list. false_Check that a type is a valid dimension list. dimensionless_typetrue_list< ItemNext >true_

Check if a unit or quantity is dimensionless. false_quantity< UnitY >boost::units::is_dimensionless< Unit >Check if a quantity is dimensionless. unit< dimensionless_typeSystem >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< UnitY >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< UnitY >Dimboost::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< UnitY >Systemboost::units::is_unit_of_system< Unit, System >

Check that a type is a unit. false_Check that a type is a unit. unit< DimSystem >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< DimSystem > >Dimtrue_unit< DimSystem >Dimtrue_

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< DimSystem > >Systemtrue_unit< DimSystem >Systemtrue_

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< UnitY >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< DimSystem >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< UnitY >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< DimSystem >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< UnitX >XPartial 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< Unit1X >boost::units::quantity< Unit2Y >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< Unit1Y >boost::units::unit< Dim2System2 >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< DimSystem >YPartial 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< Dim1System1 >boost::units::quantity< Unit2Y >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< Dim1System1 >boost::units::unit< Dim2System2 >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 >Xboost::units::quantity< UnitX >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 >Yboost::units::unit< DimSystem >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 >YPartial 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 >YPartial 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< Unit1X >boost::units::quantity< Unit2Y >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< Dim1System1 >boost::units::unit< Dim2System2 >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 >Xboost::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< DS > >TPartial 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< UnitX >XPartial 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< Unit1X >boost::units::quantity< Unit2Y >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< Unit1Y >boost::units::unit< Dim2System2 >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< DimSystem >YPartial 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< Dim1System1 >boost::units::quantity< Unit2Y >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< Dim1System1 >boost::units::unit< Dim2System2 >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 >Tboost::units::absolute< boost::units::unit< DS > >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 >Xboost::units::quantity< UnitX >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 >Yboost::units::unit< DimSystem >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 >YPartial 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 >YPartial 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< Unit1X >boost::units::quantity< Unit2Y >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< Dim1System1 >boost::units::unit< Dim2System2 >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 >Xboost::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 >Yboost::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< DimSystem >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< DimSystem >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< DimSystem > >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< DimSystem >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< DimSystem > >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< DimSystem >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 > >::typeconst 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 > >::typeconst 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 > >::typeconst 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 > >::typeconst 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 > > >::typeconst 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 > >::typeconst 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< UnitT >::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< Dimensionheterogeneous_system< heterogeneous_system_impl< UnitListDimensionOldScale > > >Scaleunit< Dimension, heterogeneous_system< heterogeneous_system_impl< UnitList, Dimension, typename mpl::times< OldScale, list< scale_list_dim< Scale >, dimensionless_type > >::type > > > unit< Dimensionheterogeneous_system< heterogeneous_system_impl< UnitListDimensionOldScale > > >scale< Basestatic_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 typeconst 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 typeconst 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 >::typeconst Y &raise a value to a static_rational power. BOOST_CONSTEXPR power_typeof_helper< Y, static_rational< N > >::typeconst Y &raise a value to an integer power. BOOST_CONSTEXPR root_typeof_helper< Y, Rat >::typeconst Y &take the static_rational root of a value. BOOST_CONSTEXPR root_typeof_helper< Y, static_rational< N > >::typeconst Y &take the integer root of a value.

quantity< unit< DimSystem >X >quantity< unit< DimSystem >Y >add_typeof_helper< X, Y >::type unit< Dim, System > quantity< unit_type, value_type > quantity< unit< Dim1System1 >X >quantity< unit< Dim2System2 >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 > &unspecified0implicit conversion between value types is allowed if allowed for value types themselves const quantity< Unit, YY > &unspecified0implicit 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 > &unspecified0explicit conversion between different unit systems is allowed if implicit conversion is disallowed const quantity< Unit2, YY > &unspecified0implicit 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_typeconst value_type &Construct quantity directly from value_type (potentially dangerous). const value_type &int BOOST_UNITS_DIMENSIONLESS_UNIT(System)YSpecialization 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_CONSTEXPRimplicit 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_typeconstruction 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 > &unspecified0implicit conversion between value types is allowed if allowed for value types themselves const quantity< unit< dimension_type, system_type >, YY > &unspecified0implicit 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 > &unspecified0unspecified0unspecified0implicit conversion between different unit systems is allowed const quantity< unit< dimensionless_type, System2 >, Y2 > &unspecified0unspecified0unspecified0implicit conversion between different unit systems is allowed const quantity< unit< dimensionless_type, System2 >, Y2 > &unspecified0conversion 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_typeconst value_type &Construct quantity directly from value_type. quantity< unit< DimSystem >X >quantity< unit< DimSystem >Y >subtract_typeof_helper< X, Y >::type unit< Dim, System > quantity< unit_type, value_type > quantity< unit< Dim1System1 >X >quantity< unit< Dim2System2 >Y > BOOST_CONSTEXPR XY &quantity_cast provides mutating access to underlying quantity value_type BOOST_CONSTEXPR Xconst Y & voidquantity< Unit, Y > &quantity< Unit, Y > &swap quantities BOOST_CONSTEXPR divide_typeof_helper< unit< Dim, System >, Y >::typeconst unit< Dim, System > &const Y &runtime unit divided by scalar BOOST_CONSTEXPR multiply_typeof_helper< Y, unit< Dim, System > >::typeconst Y &const unit< Dim, System > &runtime scalar times unit BOOST_CONSTEXPR divide_typeof_helper< Y, unit< Dim, System > >::typeconst Y &const unit< Dim, System > &runtime scalar divided by unit BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit, X >, X >::typeconst quantity< Unit, X > &const X &runtime quantity times scalar BOOST_CONSTEXPR multiply_typeof_helper< X, quantity< Unit, X > >::typeconst X &const quantity< Unit, X > &runtime scalar times quantity BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit, X >, X >::typeconst quantity< Unit, X > &const X &runtime quantity divided by scalar BOOST_CONSTEXPR divide_typeof_helper< X, quantity< Unit, X > >::typeconst X &const quantity< Unit, X > &runtime scalar divided by quantity BOOST_CONSTEXPR multiply_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >::typeconst unit< Dim1, System1 > &const quantity< Unit2, Y > &runtime unit times quantity BOOST_CONSTEXPR divide_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >::typeconst unit< Dim1, System1 > &const quantity< Unit2, Y > &runtime unit divided by quantity BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >::typeconst quantity< Unit1, Y > &const unit< Dim2, System2 > &runtime quantity times unit BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >::typeconst quantity< Unit1, Y > &const unit< Dim2, System2 > &runtime quantity divided by unit BOOST_CONSTEXPR unary_plus_typeof_helper< quantity< Unit, Y > >::typeconst quantity< Unit, Y > &runtime unary plus quantity BOOST_CONSTEXPR unary_minus_typeof_helper< quantity< Unit, Y > >::typeconst quantity< Unit, Y > &runtime unary minus quantity BOOST_CONSTEXPR add_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::typeconst quantity< Unit1, X > &const quantity< Unit2, Y > &runtime quantity plus quantity BOOST_CONSTEXPR subtract_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::typeconst quantity< Unit1, X > &const quantity< Unit2, Y > &runtime quantity minus quantity BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::typeconst quantity< Unit1, X > &const quantity< Unit2, Y > &runtime quantity times quantity BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::typeconst quantity< Unit1, X > &const quantity< Unit2, Y > &runtime quantity divided by quantity BOOST_CONSTEXPR boolconst quantity< Unit, X > &const quantity< Unit, Y > &runtime operator== BOOST_CONSTEXPR boolconst quantity< Unit, X > &const quantity< Unit, Y > &runtime operator!= BOOST_CONSTEXPR boolconst quantity< Unit, X > &const quantity< Unit, Y > &runtime operator< BOOST_CONSTEXPR boolconst quantity< Unit, X > &const quantity< Unit, Y > &runtime operator<= BOOST_CONSTEXPR boolconst quantity< Unit, X > &const quantity< Unit, Y > &runtime operator> BOOST_CONSTEXPR boolconst 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. 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::stringconst scale< Base, Exponent > & std::stringconst scale< Base, Exponent > &

traits template for unit names. std::stringThe full name of the unit (returns BaseUnit::name() by default) std::stringThe symbol for the base unit (Returns BaseUnit::symbol() by default) BaseUnit::symbol(), for example "m" TA 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. Compile time absolute value. integer_type 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 >::typeconst static_rational< N, D > &get decimal value of static_rational

unit< DimSystem >static_rational< ND >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 typeconst unit< Dim, System > & unit< DimSystem >Returns a unique type for every unit. unspecified unit< DimSystem >static_rational< ND >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 typeconst 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 > >::typeconst unit< Dim, System > &unit runtime unary plus BOOST_CONSTEXPR unary_minus_typeof_helper< unit< Dim, System > >::typeconst unit< Dim, System > &unit runtime unary minus BOOST_CONSTEXPR add_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::typeconst unit< Dim1, System1 > &const unit< Dim2, System2 > &runtime add two units BOOST_CONSTEXPR subtract_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::typeconst unit< Dim1, System1 > &const unit< Dim2, System2 > &runtime subtract two units BOOST_CONSTEXPR multiply_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::typeconst unit< Dim1, System1 > &const unit< Dim2, System2 > &runtime multiply two units BOOST_CONSTEXPR divide_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::typeconst unit< Dim1, System1 > &const unit< Dim2, System2 > &runtime divide two units BOOST_CONSTEXPR boolconst unit< Dim1, System1 > &const unit< Dim2, System2 > &unit runtime operator== BOOST_CONSTEXPR boolconst 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.