![]() |
Home | Libraries | People | FAQ | More |
Absolute units (points rather than vectors).
Operations between absolute units, and relative units like temperature differences.
BOOST_UNITS_DEFINE_CONVERSION_OFFSET(From, To, type_, value_)
template<typename Y> class absolute; // add a relative value to an absolute one template<typename Y> BOOST_CONSTEXPR absolute< Y > (const absolute< Y > & aval, const Y & rval); // add a relative value to an absolute one template<typename Y> BOOST_CONSTEXPR absolute< Y > (const Y & rval, const absolute< Y > & aval); // subtract a relative value from an absolute one template<typename Y> BOOST_CONSTEXPR absolute< Y > (const absolute< Y > & aval, const Y & rval); // subtracting two absolutes gives a difference template<typename Y> BOOST_CONSTEXPR Y (const absolute< Y > & aval1, const absolute< Y > & aval2); // creates a quantity from an absolute unit and a raw value template<typename D, typename S, typename T> BOOST_CONSTEXPR quantity< absolute< unit< D, S > >, (const t, const absolute< unit< D, S > > &); // creates a quantity from an absolute unit and a raw value template<typename D, typename S, typename T> BOOST_CONSTEXPR quantity< absolute< unit< D, S > >, (const absolute< unit< D, S > > &, const t); // Print an absolute unit. template<typename Char, typename Traits, typename Y> Char, Traits > & (Char, Traits > & os, const absolute< Y > & aval); } }
base dimensions (mass, length, time...).
base dimension definition registration.
template<typename Derived, N> class base_dimension; } }
base unit (meter, kg, sec...).
base unit definition registration.
template<typename Derived, typename Dim, N> class base_unit; } }
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.
template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR int (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR root_typeof_helper< typenameadd_typeof_helper< typenamepower_typeof_helper< quantity< Unit, Y >, static_rational< typenamepower_typeof_helper< quantity< Unit, Y >, static_rational< static_rational< (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR int (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, const quantity< Unit, Y > & q2); template<typename Unit, typename Y> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q1, quantity< Unit, Y > * q2); template<typename Unit, typename Y, typename Int> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q, Int * ex); template<typename S, typename Y> 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 > &); template<typename S, typename Y> BOOST_CONSTEXPR quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > (const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > & q); template<typename Unit, typename Y, typename Int> BOOST_CONSTEXPR quantity< Unit, Y > (const quantity< Unit, Y > & q, const Int & ex); template<typename S, typename Y> BOOST_CONSTEXPR quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > (const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > & q); template<typename S, typename Y> BOOST_CONSTEXPR quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > (const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > & q); template<typename Unit, typename Y> BOOST_CONSTEXPR root_typeof_helper< quantity< Unit, Y >, static_rational< (const quantity< Unit, Y > & q); // cos of theta in radians template<typename Y> BOOST_CONSTEXPR dimensionless_quantity< Y >:: (const quantity< Y > & theta); // sin of theta in radians template<typename Y> BOOST_CONSTEXPR dimensionless_quantity< Y >:: (const quantity< Y > & theta); // tan of theta in radians template<typename Y> BOOST_CONSTEXPR dimensionless_quantity< Y >:: (const quantity< Y > & theta); // cos of theta in other angular units template<typename System, typename Y> BOOST_CONSTEXPR dimensionless_quantity< System, Y >:: (const quantity< unit< plane_angle_dimension, System >, Y > & theta); // sin of theta in other angular units template<typename System, typename Y> BOOST_CONSTEXPR dimensionless_quantity< System, Y >:: (const quantity< unit< plane_angle_dimension, System >, Y > & theta); // tan of theta in other angular units template<typename System, typename Y> BOOST_CONSTEXPR dimensionless_quantity< System, Y >:: (const quantity< unit< plane_angle_dimension, System >, Y > & theta); // acos of dimensionless quantity returning angle in same system template<typename Y, typename System> BOOST_CONSTEXPR quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > (const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // acos of dimensionless quantity returning angle in radians template<typename Y> BOOST_CONSTEXPR quantity< Y > (const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); // asin of dimensionless quantity returning angle in same system template<typename Y, typename System> BOOST_CONSTEXPR quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > (const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // asin of dimensionless quantity returning angle in radians template<typename Y> BOOST_CONSTEXPR quantity< Y > (const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); // atan of dimensionless quantity returning angle in same system template<typename Y, typename System> BOOST_CONSTEXPR quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > (const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // atan of dimensionless quantity returning angle in radians template<typename Y> BOOST_CONSTEXPR quantity< Y > (const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); // atan2 ofvalue_type
returning angle in radians template<typename Y, typename Dimension, typename System> BOOST_CONSTEXPR quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > (const quantity< unit< Dimension, homogeneous_system< System > >, Y > & y, const quantity< unit< Dimension, homogeneous_system< System > >, Y > & x); // atan2 ofvalue_type
returning angle in radians template<typename Y, typename Dimension, typename System> BOOST_CONSTEXPR quantity< Y > (const quantity< unit< Dimension, heterogeneous_system< System > >, Y > & y, const quantity< unit< Dimension, heterogeneous_system< System > >, Y > & x); } }
BOOST_UNITS_REQUIRE_LAYOUT_COMPATIBILITY BOOST_UNITS_NO_COMPILER_CHECK BOOST_UNITS_CHECK_HOMOGENEOUS_UNITS
Template for defining conversions between quantities.
BOOST_UNITS_DEFINE_CONVERSION_FACTOR(Source, Destination, type_, value_) BOOST_UNITS_DEFINE_CONVERSION_FACTOR_TEMPLATE(Params, Source, Destination, type_, value_) BOOST_UNITS_DEFAULT_CONVERSION(Source, Dest) BOOST_UNITS_DEFAULT_CONVERSION_TEMPLATE(Params, Source, Dest)
template<typename From, typename To> struct conversion_helper; // Find the conversion factor between two units. template<typename FromUnit, typename ToUnit> (const FromUnit &, const ToUnit &); } }
template<typename DT1 = dimensionless_type, E1 = , typename DT2 = dimensionless_type, E2 = , typename DT3 = dimensionless_type, E3 = , typename DT4 = dimensionless_type, E4 = , typename DT5 = dimensionless_type, E5 = , typename DT6 = dimensionless_type, E6 = , typename DT7 = dimensionless_type, E7 = , typename DT8 = dimensionless_type, E8 = > struct derived_dimension; } }
Handling of fundamental dimension/exponent pairs.
template<typename T, typename V> struct dim; } }
Core metaprogramming utilities for compile-time dimensional analysis.
template<typename Seq> struct make_dimension_list; template<typename DL, typename Ex> struct static_power; template<typename DL, typename Rt> struct static_root; } }
Utility class to simplify construction of dimensionless quantities.
template<typename System, typename Y> struct dimensionless_quantity; } }
Dimension lists in which all exponents resolve to zero reduce to dimensionless_type
.
struct dimensionless_type; } }
Utility class to simplify construction of dimensionless units in a system.
template<typename System> struct dimensionless_unit; } }
Get the dimension of a unit, absolute unit and quantity.
template<typename T> struct get_dimension; template<typename Unit> struct get_dimension<>; template<typename Unit, typename Y> struct get_dimension<, >; template<typename Dim, typename System> struct get_dimension<, >; } }
Get the system of a unit, absolute unit or quantity.
template<typename T> struct get_system; template<typename Unit> struct get_system<>; template<typename Unit, typename Y> struct get_system<, >; template<typename Dim, typename System> struct get_system<, >; } }
A heterogeneous system is a sorted list of base unit/exponent pairs.
} template<typename T> struct heterogeneous_system; } }
template<typename L> struct homogeneous_system; } }
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.
// Boost Serialization library support for units. template<typename Archive, typename System, typename Dim> (, boost::units::unit< , ); // Boost Serialization library support for quantities. template<typename Archive, typename Unit, typename Y> ( ar, boost::units::quantity< q, ); } template<typename BaseUnit> struct base_unit_info; // format of output of units, for example "m" or "meter". enum format_mode { symbol_fmt = = 0, name_fmt = = 1, raw_fmt = = 2, typename_fmt = = 3, fmt_mask = = 3 }; // automatic scaling and prefix (controlled by value of quantity) a, if any, enum autoprefix_mode { autoprefix_none = = 0, autoprefix_engineering = = 4, autoprefix_binary = = 8, autoprefix_mask = = 12 }; template<typename T> (const t); // get string representation of integral-valuedstatic_rational
. template< N> (const static_rational< N > &); // get string representation ofstatic_rational
. template< N, D> (const static_rational< N, D > &); // Writestatic_rational
tostd::basic_ostream
. template<typename Char, typename Traits, N, D> Char, Traits > & (Char, Traits > & os, const static_rational< N, D > & r); // returns flags controlling output. long ( ios, long mask); // Set new flags controlling output format. void ( ios, long new_flags, long mask); // returns flags controlling output format. ( ios); // Set new flags controlling output format. void ( ios, new_mode); // Set new flags for type_name output format. ( ios); // set new flag for raw format output, for example "m". ( ios); // set new format flag for symbol output, for example "m". ( ios); // set new format for name output, for example "meter". ( ios); // get autoprefix flags for output. ( ios); // Get format for output. void ( ios, new_mode); // Clear autoprefix flags. ( ios); // Set flag for engineering prefix, so 1234.5 m displays as "1.2345 km". ( ios); // Set flag for binary prefix, so 1024 byte displays as "1 Kib". ( ios); template<typename T> double (const ); template<typename Dimension, typename System> (const unit< Dimension, System > &); template<typename Dimension, typename System> (const unit< Dimension, System > &); template<typename Dimension, typename System> (const unit< Dimension, System > &); template<typename Char, typename Traits, typename Dimension, typename System> Char, Traits > & (Char, Traits > &, const unit< Dimension, System > &); template<typename Char, typename Traits, typename Unit, typename T> Char, Traits > & (Char, Traits > &, const quantity< Unit, ); } }
Check that a type is a valid dim
.
template<typename T> struct is_dim; template<typename T, typename V> struct is_dim<, >; } }
Check that a type is a valid dimension list.
template<typename Seq> struct is_dimension_list; template<> struct is_dimension_list<>; template<typename Item, typename Next> struct is_dimension_list<, >; } }
Check if a unit or quantity is dimensionless.
template<typename T> struct is_dimensionless; template<typename Unit, typename Y> struct is_dimensionless<, >; template<typename System> struct is_dimensionless<, >; } }
check that a type is a dimensionless quantity
template<typename T> struct is_dimensionless_quantity; } }
Check that a type is a dimensionless unit.
template<typename T> struct is_dimensionless_unit; } }
Check that a type is a quantity.
template<typename T> struct is_quantity; template<typename Unit, typename Y> struct is_quantity<, >; } }
Check that a type is a quantity of the specified dimension.
template<typename T, typename Dim> struct is_quantity_of_dimension; template<typename Unit, typename Y, typename Dim> struct is_quantity_of_dimension<, , >; } }
Check that a type is a quantity in a specified system.
template<typename T, typename System> struct is_quantity_of_system; template<typename Unit, typename Y, typename System> struct is_quantity_of_system<, , >; } }
Check that a type is a unit.
template<typename T> struct is_unit; template<typename Dim, typename System> struct is_unit<, >; } }
Check that a type is a unit of the specified dimension.
template<typename T, typename Dim> struct is_unit_of_dimension; template<typename Dim, typename System> struct is_unit_of_dimension<, , >; template<typename Dim, typename System> struct is_unit_of_dimension<, , >; } }
Check that a type is a unit in a specified system.
template<typename T, typename System> struct is_unit_of_system; template<typename Dim, typename System> struct is_unit_of_system<, , >; template<typename Dim, typename System> struct is_unit_of_system<, , >; } }
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.
template<typename Unit, typename Y> struct plain_return_type_1<, , >; template<typename Dim, typename System> struct plain_return_type_1<, , >; template<typename Unit, typename Y> struct plain_return_type_1<, , >; template<typename Dim, typename System> struct plain_return_type_1<, , >; template<typename Unit, typename X> struct plain_return_type_2<, , , >; template<typename Unit1, typename X, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Unit1, typename Y, typename System2, typename Dim2> struct plain_return_type_2<, , , , >; template<typename System, typename Dim, typename Y> struct plain_return_type_2<, , , >; template<typename System1, typename Dim1, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Dim1, typename Dim2, typename System1, typename System2> struct plain_return_type_2<, , , , >; template<typename Unit, typename X> struct plain_return_type_2<, , , >; template<typename System, typename Dim, typename Y> struct plain_return_type_2<, , , >; template<typename Y> struct plain_return_type_2<, , >; template<typename Y> struct plain_return_type_2<, , >; template<typename System, typename X, typename Y> struct plain_return_type_2<, , , >; template<typename Unit1, typename X, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Dim1, typename Dim2, typename System1, typename System2> struct plain_return_type_2<, , , , >; template<typename System, typename X, typename Y> struct plain_return_type_2<, , , >; template<typename D, typename S, typename T> struct plain_return_type_2<, , , >; template<typename Unit, typename X> struct plain_return_type_2<, , , >; template<typename Unit1, typename X, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Unit1, typename Y, typename System2, typename Dim2> struct plain_return_type_2<, , , , >; template<typename System, typename Dim, typename Y> struct plain_return_type_2<, , , >; template<typename System1, typename Dim1, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Dim1, typename Dim2, typename System1, typename System2> struct plain_return_type_2<, , , , >; template<typename D, typename S, typename T> struct plain_return_type_2<, , , >; template<typename Unit, typename X> struct plain_return_type_2<, , , >; template<typename System, typename Dim, typename Y> struct plain_return_type_2<, , , >; template<typename Y> struct plain_return_type_2<, , >; template<typename System, typename X, typename Y> struct plain_return_type_2<, , , >; template<typename Unit1, typename X, typename Unit2, typename Y> struct plain_return_type_2<, , , , >; template<typename Dim1, typename Dim2, typename System1, typename System2> struct plain_return_type_2<, , , , >; template<typename System, typename X, typename Y> struct plain_return_type_2<, , , >; template<typename Y> struct plain_return_type_2<, , >; } template<typename System, typename Dim, typename Arg> struct divide_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> struct divide_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> struct multiply_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> struct multiply_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> struct multiply_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> struct multiply_typeof_helper<, , >; template<typename System, typename Dim, typename Arg> const multiply_typeof_helper< boost::units::unit< Dim, System >, Arg > >:: (const boost::units::unit< Dim, System > &, const Arg > &); template<typename System, typename Dim, typename Arg> const divide_typeof_helper< boost::units::unit< Dim, System >, Arg > >:: (const boost::units::unit< Dim, System > &, const Arg > &); template<typename System, typename Dim, typename Arg> const multiply_typeof_helper< Arg >, boost::units::unit< Dim, System > >:: (const Arg > &, const boost::units::unit< Dim, System > &); template<typename System, typename Dim, typename Arg> const divide_typeof_helper< Arg >, boost::units::unit< Dim, System > >:: (const Arg > &, const boost::units::unit< Dim, System > &); template<typename System, typename Dim, typename Arg> const multiply_typeof_helper< Arg >, boost::units::absolute< boost::units::unit< Dim, System > > >:: (const Arg > &, const boost::units::absolute< boost::units::unit< Dim, System > > &); template<typename System, typename Dim, typename Arg> const multiply_typeof_helper< boost::units::absolute< boost::units::unit< Dim, System > >, Arg > >:: (const boost::units::absolute< boost::units::unit< Dim, System > > &, const Arg > &); } }
specialize std::numeric_limits for units.
template<typename Unit, typename T> class numeric_limits<::, >; }
template<typename Unit, typename Scale> struct make_scaled_unit; template<typename Dimension, typename UnitList, typename OldScale, typename Scale> struct make_scaled_unit<, , , , >; template<typename Dimension, typename UnitList, typename OldScale, Base> struct make_scaled_unit<, , , , , >; } }
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.
template<typename BaseUnit0, typename BaseUnit1, typename BaseUnit2, ... , typename BaseUnitN> struct make_system; } }
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.
template<typename X, typename Y> struct add_typeof_helper; template<typename X, typename Y> struct divide_typeof_helper; template<typename X, typename Y> struct multiply_typeof_helper; template<typename BaseType, typename Exponent> struct power_typeof_helper; template<typename Radicand, typename Index> struct root_typeof_helper; template<typename X, typename Y> struct subtract_typeof_helper; template<typename X> struct unary_minus_typeof_helper; template<typename X> struct unary_plus_typeof_helper; } }
Raise values to exponents known at compile-time.
// raise a value to astatic_rational
power. template<typename Rat, typename Y> BOOST_CONSTEXPR power_typeof_helper< Y, Rat >:: (const Y & x); // raise a value to an integer power. template< N, typename Y> BOOST_CONSTEXPR power_typeof_helper< Y, static_rational< N > >:: (const Y & x); // take thestatic_rational
root of a value. template<typename Rat, typename Y> BOOST_CONSTEXPR root_typeof_helper< Y, Rat >:: (const Y & x); // take the integer root of a value. template< N, typename Y> BOOST_CONSTEXPR root_typeof_helper< Y, static_rational< N > >:: (const Y & x); } }
template<typename Dim, typename System, typename X, typename Y> struct add_typeof_helper<, , , , , >; template<typename Dim1, typename System1, typename Dim2, typename System2, typename X, typename Y> struct add_typeof_helper<, , , , , >; template<typename Unit, typename Y> class quantity; template<typename System, typename Y> class quantity<, >; template<typename Dim, typename System, typename X, typename Y> struct subtract_typeof_helper<, , , , , >; template<typename Dim1, typename System1, typename Dim2, typename System2, typename X, typename Y> struct subtract_typeof_helper<, , , , , >; // quantity_cast provides mutating access to underlying quantity value_type template<typename X, typename Y> BOOST_CONSTEXPR X (Y & source); template<typename X, typename Y> BOOST_CONSTEXPR X (const Y & source); // swap quantities template<typename Unit, typename Y> void (quantity< Unit, Y > & lhs, quantity< Unit, Y > & rhs); // runtime unit divided by scalar template<typename System, typename Dim, typename Y> BOOST_CONSTEXPR divide_typeof_helper< unit< Dim, System >, Y >:: (const unit< Dim, System > &, const Y & rhs); // runtime scalar times unit template<typename System, typename Dim, typename Y> BOOST_CONSTEXPR multiply_typeof_helper< Y, unit< Dim, System > >:: (const Y & lhs, const unit< Dim, System > &); // runtime scalar divided by unit template<typename System, typename Dim, typename Y> BOOST_CONSTEXPR divide_typeof_helper< Y, unit< Dim, System > >:: (const Y & lhs, const unit< Dim, System > &); // runtime quantity times scalar template<typename Unit, typename X> BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit, X >, X >:: (const quantity< Unit, X > & lhs, const X & rhs); // runtime scalar times quantity template<typename Unit, typename X> BOOST_CONSTEXPR multiply_typeof_helper< X, quantity< Unit, X > >:: (const X & lhs, const quantity< Unit, X > & rhs); // runtime quantity divided by scalar template<typename Unit, typename X> BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit, X >, X >:: (const quantity< Unit, X > & lhs, const X & rhs); // runtime scalar divided by quantity template<typename Unit, typename X> BOOST_CONSTEXPR divide_typeof_helper< X, quantity< Unit, X > >:: (const X & lhs, const quantity< Unit, X > & rhs); // runtime unit times quantity template<typename System1, typename Dim1, typename Unit2, typename Y> BOOST_CONSTEXPR multiply_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >:: (const unit< Dim1, System1 > &, const quantity< Unit2, Y > & rhs); // runtime unit divided by quantity template<typename System1, typename Dim1, typename Unit2, typename Y> BOOST_CONSTEXPR divide_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >:: (const unit< Dim1, System1 > &, const quantity< Unit2, Y > & rhs); // runtime quantity times unit template<typename Unit1, typename System2, typename Dim2, typename Y> BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >:: (const quantity< Unit1, Y > & lhs, const unit< Dim2, System2 > &); // runtime quantity divided by unit template<typename Unit1, typename System2, typename Dim2, typename Y> BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >:: (const quantity< Unit1, Y > & lhs, const unit< Dim2, System2 > &); // runtime unary plus quantity template<typename Unit, typename Y> BOOST_CONSTEXPR unary_plus_typeof_helper< quantity< Unit, Y > >:: (const quantity< Unit, Y > & val); // runtime unary minus quantity template<typename Unit, typename Y> BOOST_CONSTEXPR unary_minus_typeof_helper< quantity< Unit, Y > >:: (const quantity< Unit, Y > & val); // runtime quantity plus quantity template<typename Unit1, typename Unit2, typename X, typename Y> BOOST_CONSTEXPR add_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >:: (const quantity< Unit1, X > & lhs, const quantity< Unit2, Y > & rhs); // runtime quantity minus quantity template<typename Unit1, typename Unit2, typename X, typename Y> BOOST_CONSTEXPR subtract_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >:: (const quantity< Unit1, X > & lhs, const quantity< Unit2, Y > & rhs); // runtime quantity times quantity template<typename Unit1, typename Unit2, typename X, typename Y> BOOST_CONSTEXPR multiply_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >:: (const quantity< Unit1, X > & lhs, const quantity< Unit2, Y > & rhs); // runtime quantity divided by quantity template<typename Unit1, typename Unit2, typename X, typename Y> BOOST_CONSTEXPR divide_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >:: (const quantity< Unit1, X > & lhs, const quantity< Unit2, Y > & rhs); // runtime operator== template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); // runtime operator!= template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); // runtime operator< template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); // runtime operator<= template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); // runtime operator> template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); // runtime operator>= template<typename Unit, typename X, typename Y> BOOST_CONSTEXPR bool (const quantity< Unit, X > & val1, const quantity< Unit, Y > & val2); } }
Returns a unique type for every unit.
template<typename Unit> struct reduce_unit; } }
10^3 Engineering & 2^10 binary scaling factors for autoprefixing.
template< Base, typename Exponent> struct scale; template< Base, typename Exponent> (const scale< Base, Exponent > &); template< Base, typename Exponent> (const scale< Base, Exponent > &); } }
template<typename S, typename Scale> struct scaled_base_unit; } }
BOOST_UNITS_STATIC_CONSTANT(name, type)
Compile-time rational numbers and operators.
template< Value> struct static_abs;
template< N, D = > class static_rational;
typedef long ;
// get decimal value of static_rational
template<typename T, N, D>
BOOST_CONSTEXPR divide_typeof_helper<
(const static_rational< N, D > &);
}
}
template<typename Dim, typename System, N, D> struct power_typeof_helper<, , , >; template<typename Dim, typename System> struct reduce_unit<, >; template<typename Dim, typename System, N, D> struct root_typeof_helper<, , , >; template<typename Dim, typename System, typename Enable> class unit; // unit runtime unary plus template<typename Dim, typename System> BOOST_CONSTEXPR unary_plus_typeof_helper< unit< Dim, System > >:: (const unit< Dim, System > &); // unit runtime unary minus template<typename Dim, typename System> BOOST_CONSTEXPR unary_minus_typeof_helper< unit< Dim, System > >:: (const unit< Dim, System > &); // runtime add two units template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR add_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >:: (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); // runtime subtract two units template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR subtract_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >:: (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); // runtime multiply two units template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR multiply_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >:: (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); // runtime divide two units template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR divide_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >:: (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); // unit runtimeoperator==
template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR bool (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); // unit runtimeoperator!=
template<typename Dim1, typename Dim2, typename System1, typename System2> BOOST_CONSTEXPR bool (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &); } }
Forward declarations of library components.
Forward declarations of units library - dimensions, systems, quantity and string components.
Physical dimensions according to the SI system.
This header includes all physical dimension headers for both base and derived dimensions.
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for absorbed dose : L^2 T^-2 } }
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for acceleration : L T^-2 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,- ; // derived dimension for action : L^2 M T^-1 } }
typedef time_base_dimension,- ; // derived dimension for activity : T^-1 } }
struct amount_base_dimension; typedef ; // dimension of amount of substance (N) } }
typedef time_base_dimension,-plane_angle_base_dimension, ; // derived dimension for angular acceleration : T^-2 QP } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-plane_angle_base_dimension,- ; // derived dimension for angular momentum : L^2 M T^-1 QP^-1 } }
typedef time_base_dimension,-plane_angle_base_dimension, ; // derived dimension for angular velocity : T^-1 QP } }
typedef length_base_dimension, ; // derived dimension for area : L^2 } }
typedef length_base_dimension,-mass_base_dimension,-time_base_dimension, current_base_dimension, ; // derived dimension for capacitance : L^-2 M^-1 T^4 I^2 } }
typedef length_base_dimension,-mass_base_dimension,-time_base_dimension, current_base_dimension, ; // derived dimension for conductance : L^-2 M^-1 T^3 I^2 } }
typedef length_base_dimension,-mass_base_dimension,-time_base_dimension, current_base_dimension, ; // derived dimension for conductivity : L^-3 M^-1 T^3 I^2 } }
struct current_base_dimension; typedef ; // dimension of electric current (I) } }
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for dose equivalent : L^2 T^-2 } }
typedef mass_base_dimension, length_base_dimension,-time_base_dimension,- ; // derived dimension for dynamic viscosity : M L^-1 T^-1 } }
typedef time_base_dimension, current_base_dimension, ; // derived dimension for electric charge : T^1 I^1 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for electric potential : L^2 M T^-3 I^-1 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,- ; // derived dimension for energy : L^2 M T^-2 } }
typedef length_base_dimension,-mass_base_dimension, time_base_dimension,- ; // derived dimension for energy density : L^-1 M^1 T^-2 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,- ; // derived dimension for force : L M T^-2 } }
typedef time_base_dimension,- ; // derived dimension for frequency : T^-1 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-temperature_base_dimension,- ; // derived dimension for heat capacity : L^2 M T^-2 Theta^-1 } }
typedef length_base_dimension,-luminous_intensity_base_dimension, solid_angle_base_dimension, ; // derived dimension for illuminance : L^-2 I QS } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for impedance : L^2 M T^-3 I^-2
} }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for inductance : L^2 M T^-2 I^-2 } }
struct information_base_dimension; typedef ; // dimension of information } }
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for kinematic viscosity : L^2 T^-1 } }
struct length_base_dimension; typedef ; // dimension of length (L) } }
typedef length_base_dimension,-luminous_intensity_base_dimension, ; // derived dimension for luminance : L^-2 I } }
typedef luminous_intensity_base_dimension, solid_angle_base_dimension, ; // derived dimension for luminous flux : I QS } }
struct luminous_intensity_base_dimension; typedef ; // dimension of luminous intensity (J) } }
typedef length_base_dimension,-current_base_dimension, ; // derived dimension for magnetic field intensity : L^-1 I } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for magnetic flux : L^2 M T^-2 I^-1 } }
typedef mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for magnetic flux density : M T^-2 I^-1 } }
struct mass_base_dimension; typedef ; // dimension of mass (M) } }
typedef length_base_dimension,-mass_base_dimension, ; // derived dimension for mass density : L^-3 M } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-amount_base_dimension,- ; // derived dimension for molar energy : L^2 M T^-2 N^-1 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-temperature_base_dimension,-amount_base_dimension,- ; // derived dimension for molar heat capacity : L^2 M T^-2 Theta^-1 N^-1 } }
typedef length_base_dimension, mass_base_dimension, plane_angle_base_dimension,- ; // derived dimension for moment of inertia : L^2 M QP^-2 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,- ; // derived dimension for linear momentum : L M T^-1 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for permeability : L M T^-2 I^-2 } }
typedef length_base_dimension,-mass_base_dimension,-time_base_dimension, current_base_dimension, ; // derived dimension for permittivity : L^-3 M^-1 T^4 I^2 } }
struct plane_angle_base_dimension; typedef ; // base dimension of plane angle (QP) } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,- ; // derived dimension for power : L^2 M T^-3 } }
typedef length_base_dimension,-mass_base_dimension, time_base_dimension,- ; // derived dimension for pressure : L^-1 M T^-2 } }
typedef length_base_dimension,-mass_base_dimension,-time_base_dimension, current_base_dimension, ; // derived dimension for reluctance : L^-2 M^-1 T^2 I^2 } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for resistance : L^2 M T^-3 I^-2
} }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-current_base_dimension,- ; // derived dimension for resistivity : L^3 M T^-3 I^-2 } }
struct solid_angle_base_dimension; typedef ; // base dimension of solid angle (QS) } }
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for specific energy : L^2 T^-2 } }
typedef length_base_dimension, time_base_dimension,-temperature_base_dimension,- ; // derived dimension for specific heat capacity : L^2 T^-2 Theta^-1 } }
typedef length_base_dimension, mass_base_dimension,- ; // derived dimension for specific volume : L^3 M^-1 } }
typedef length_base_dimension,-mass_base_dimension, time_base_dimension,- ; // derived dimension for stress : L^-1 M T^-2 } }
typedef length_base_dimension,-mass_base_dimension, ; // derived dimension for surface density : L^-2 M } }
typedef mass_base_dimension, time_base_dimension,- ; // derived dimension for surface tension : M T^-2 } }
struct temperature_base_dimension; typedef ; // dimension of temperature (Theta) } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-temperature_base_dimension,- ; // derived dimension for thermal_conductivity : L^1 M^1 T^-3 Theta^-1 } }
struct time_base_dimension; typedef ; // dimension of time (T) } }
typedef length_base_dimension, mass_base_dimension, time_base_dimension,-plane_angle_base_dimension,- ; // derived dimension for torque : L^2 M T^-2 QP^-1 } }
typedef length_base_dimension, time_base_dimension,- ; // derived dimension for velocity : L T^-1 } }
typedef length_base_dimension, ; // derived dimension for volume : l^3 } }
typedef length_base_dimension,- ; // derived dimension for wavenumber : L^-1 } }
Includes all the si unit headers
typedef ; static meter_per_second_squared; static meters_per_second_squared; static metre_per_second_squared; static metres_per_second_squared; } } }
typedef ; } } }
typedef ; static becquerel; static becquerels; } } }
typedef ; static mole; static moles; } } }
typedef ; static radian_per_second; static radians_per_second; } } }
typedef ; static square_meter; static square_meters; static square_metre; static square_metres; } } }
typedef ; // placeholder class defining si unit system typedef ; // dimensionless si unit } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // alpha-electron mass ratio (, , dimensionless, dimensionless); // alpha-proton mass ratio (, , dimensionless, dimensionless); // alpha molar mass (, , mole, mole); } } } } }
(, , , ); // Rydberg constant. (, , meter, meter); // Bohr radius. (, , meters, meters); // Hartree energy. (, , joules, joules); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // deuteron-electron mass ratio (, , dimensionless, dimensionless); // deuteron-proton mass ratio (, , dimensionless, dimensionless); // deuteron molar mass (, , mole, mole); // deuteron rms charge radius (, , meters, meters); // deuteron magnetic moment (, , tesla, tesla); // deuteron-Bohr magneton ratio (, , dimensionless, dimensionless); // deuteron-nuclear magneton ratio (, , dimensionless, dimensionless); // deuteron g-factor (, , dimensionless, dimensionless); // deuteron-electron magnetic moment ratio (, , - dimensionless, dimensionless); // deuteron-proton magnetic moment ratio (, , dimensionless, dimensionless); // deuteron-neutron magnetic moment ratio (, , - dimensionless, dimensionless); } } } } }
CODATA recommended values of fundamental electromagnetic constants.
CODATA recommended values of the fundamental physical constants: NIST SP 961 CODATA 2006 values as of 2007/03/30
// elementary charge (, , coulombs, coulombs); // elementary charge to Planck constant ratio (, , joule, joule); // magnetic flux quantum (, , webers, webers); // conductance quantum (, , siemens, siemens); // Josephson constant. (, , volt, volt); // von Klitzing constant (, , ohms, ohms); // Bohr magneton. (, , tesla, tesla); // nuclear magneton (, , tesla, tesla); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // electron-muon mass ratio (, , dimensionless, dimensionless); // electron-tau mass ratio (, , dimensionless, dimensionless); // electron-proton mass ratio (, , dimensionless, dimensionless); // electron-neutron mass ratio (, , dimensionless, dimensionless); // electron-deuteron mass ratio (, , dimensionless, dimensionless); // electron-alpha particle mass ratio (, , dimensionless, dimensionless); // electron charge to mass ratio (, , kilogram, kilogram); // electron molar mass (, , mole, mole); // Compton wavelength. (, , meters, meters); // classical electron radius (, , meters, meters); // Thompson cross section. (, , square_meters, square_meters); // electron magnetic moment (, , - tesla, tesla); // electron-Bohr magenton moment ratio (, , - dimensionless, dimensionless); // electron-nuclear magneton moment ratio (, , - dimensionless, dimensionless); // electron magnetic moment anomaly (, , dimensionless, dimensionless); // electron g-factor (, , - dimensionless, dimensionless); // electron-muon magnetic moment ratio (, , dimensionless, dimensionless); // electron-proton magnetic moment ratio (, , - dimensionless, dimensionless); // electron-shielded proton magnetic moment ratio (, , - dimensionless, dimensionless); // electron-neutron magnetic moment ratio (, , dimensionless, dimensionless); // electron-deuteron magnetic moment ratio (, , - dimensionless, dimensionless); // electron-shielded helion magnetic moment ratio (, , dimensionless, dimensionless); // electron gyromagnetic ratio (, , tesla, tesla); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // helion-electron mass ratio (, , dimensionless, dimensionless); // helion-proton mass ratio (, , dimensionless, dimensionless); // helion molar mass (, , mole, mole); // helion shielded magnetic moment (, , - tesla, tesla); // shielded helion-Bohr magneton ratio (, , - dimensionless, dimensionless); // shielded helion-nuclear magneton ratio (, , - dimensionless, dimensionless); // shielded helion-proton magnetic moment ratio (, , - dimensionless, dimensionless); // shielded helion-shielded proton magnetic moment ratio (, , - dimensionless, dimensionless); // shielded helion gyromagnetic ratio (, , tesla, tesla); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // muon-electron mass ratio (, , dimensionless, dimensionless); // muon-tau mass ratio (, , dimensionless, dimensionless); // muon-proton mass ratio (, , dimensionless, dimensionless); // muon-neutron mass ratio (, , dimensionless, dimensionless); // muon molar mass (, , mole, mole); // muon Compton wavelength (, , meters, meters); // muon magnetic moment (, , - tesla, tesla); // muon-Bohr magneton ratio (, , - dimensionless, dimensionless); // muon-nuclear magneton ratio (, , - dimensionless, dimensionless); // muon magnetic moment anomaly (, , dimensionless, dimensionless); // muon g-factor (, , - dimensionless, dimensionless); // muon-proton magnetic moment ratio (, , - dimensionless, dimensionless); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // neutron-electron mass ratio (, , dimensionless, dimensionless); // neutron-muon mass ratio (, , dimensionless, dimensionless); // neutron-tau mass ratio (, , dimensionless, dimensionless); // neutron-proton mass ratio (, , dimensionless, dimensionless); // neutron molar mass (, , mole, mole); // neutron Compton wavelength (, , meters, meters); // neutron magnetic moment (, , - tesla, tesla); // neutron g-factor (, , - dimensionless, dimensionless); // neutron-electron magnetic moment ratio (, , dimensionless, dimensionless); // neutron-proton magnetic moment ratio (, , - dimensionless, dimensionless); // neutron-shielded proton magnetic moment ratio (, , - dimensionless, dimensionless); // neutron gyromagnetic ratio (, , tesla, tesla); } } } } }
CODATA recommended values of fundamental physico-chemical constants CODATA 2014 values as of 2016/04/26
// Avogadro constant. (, , mole, mole); // atomic mass constant (, , kilograms, kilograms); // Faraday constant. (, , mole, mole); // molar gas constant (, , mole, mole); // Boltzmann constant. (, , kelvin, kelvin); // Stefan-Boltzmann constant. (, , , ); // first radiation constant (, , square_meters, square_meters); // first radiation constant for spectral radiance (, , steradian, steradian); // second radiation constant (, , kelvin, kelvin); // Wien displacement law constant : lambda_max T. (, , kelvin, kelvin); // Wien displacement law constant : nu_max/T. (, , kelvin, kelvin); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // proton-electron mass ratio (, , dimensionless, dimensionless); // proton-muon mass ratio (, , dimensionless, dimensionless); // proton-tau mass ratio (, , dimensionless, dimensionless); // proton-neutron mass ratio (, , dimensionless, dimensionless); // proton charge to mass ratio (, , kilogram, kilogram); // proton molar mass (, , mole, mole); // proton Compton wavelength (, , meters, meters); // proton rms charge radius (, , meters, meters); // proton magnetic moment (, , tesla, tesla); // proton-Bohr magneton ratio (, , dimensionless, dimensionless); // proton-nuclear magneton ratio (, , dimensionless, dimensionless); // proton g-factor (, , dimensionless, dimensionless); // proton-neutron magnetic moment ratio (, , - dimensionless, dimensionless); // shielded proton magnetic moment (, , tesla, tesla); // shielded proton-Bohr magneton ratio (, , dimensionless, dimensionless); // shielded proton-nuclear magneton ratio (, , dimensionless, dimensionless); // proton magnetic shielding correction (, , dimensionless, dimensionless); // proton gyromagnetic ratio (, , tesla, tesla); // shielded proton gyromagnetic ratio (, , tesla, tesla); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // tau-electron mass ratio (, , dimensionless, dimensionless); // tau-muon mass ratio (, , dimensionless, dimensionless); // tau-proton mass ratio (, , dimensionless, dimensionless); // tau-neutron mass ratio (, , dimensionless, dimensionless); // tau molar mass (, , mole, mole); // tau Compton wavelength (, , meters, meters); } } } } }
CODATA recommended values of fundamental atomic and nuclear constants CODATA 2006 values as of 2007/03/30
(, , , ); // triton-electron mass ratio (, , dimensionless, dimensionless); // triton-proton mass ratio (, , dimensionless, dimensionless); // triton molar mass (, , mole, mole); // triton magnetic moment (, , tesla, tesla); // triton-Bohr magneton ratio (, , dimensionless, dimensionless); // triton-nuclear magneton ratio (, , dimensionless, dimensionless); // triton g-factor (, , dimensionless, dimensionless); // triton-electron magnetic moment ratio (, , - dimensionless, dimensionless); // triton-proton magnetic moment ratio (, , dimensionless, dimensionless); // triton-neutron magnetic moment ratio (, , - dimensionless, dimensionless); } } } } }
typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; } } } } }
CODATA recommended values of fundamental universal constants using CODATA 2006 values as of 2007/03/30
(, , , ); // magnetic constant (exactly 4 pi x 10^(-7) - error is due to finite precision of pi) (, , ampere, ampere); // electric constant (, , meter, meter); // characteristic impedance of vacuum (, , ohm, ohm); // Newtonian constant of gravitation. (, , second, second); // Planck constant. (, , seconds, seconds); // Dirac constant. (, , seconds, seconds); // Planck mass. (, , kilograms, kilograms); // Planck temperature. (, , kelvin, kelvin); // Planck length. (, , meters, meters); // Planck time. (, , seconds, seconds); } } } } }
typedef ; static ampere; static amperes; } } }
typedef ; static joule; static joules; } } }
typedef ; static newton; static newtons; } } }
typedef ; static hertz; } } }
typedef ; static lux; } } }
typedef ; } } }
(); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); } }
typedef ; static meter; static meters; static metre; static metres; } } }
typedef ; static kilogram; static kilograms; static kilogramme; static kilogrammes; } } }
typedef ; static kilogram_per_cubic_meter; static kilograms_per_cubic_meter; static kilogramme_per_cubic_metre; static kilogrammes_per_cubic_metre; } } }
typedef ; } } }
typedef ; static watt; static watts; } } }
BOOST_UNITS_METRIC_PREFIX(exponent, name)
(- 24, ); (- 21, ); (- 18, ); (- 15, ); (- 12, ); (- 9, ); (- 6, ); (- 3, ); (- 2, ); (- 1, ); (, ); (, ); (, ); (, ); (, ); (, ); (, ); (, ); (, ); (, ); } } }
typedef ; static pascal; static pascals; } } }
typedef ; static steradian; static steradians; } } }
typedef ; static kilogram_per_square_meter; static kilograms_per_square_meter; static kilogramme_per_square_metre; static kilogrammes_per_square_metre; } } }
typedef ; static newton_per_meter; static newtons_per_meter; } } }
typedef ; static second; static seconds; } } }
typedef ; static newton_meter; static newton_meters; } } }
typedef ; static meter_per_second; static meters_per_second; static metre_per_second; static metres_per_second; } } }
typedef ; static cubic_meter; static cubic_meters; static cubic_metre; static cubic_metres; } } }
typedef ; static reciprocal_meter; static reciprocal_meters; static reciprocal_metre; static reciprocal_metres; } } }
Includes all the cgs unit headers
typedef ; static square_centimeter; static square_centimeters; static square_centimetre; static square_centimetres; } } }
typedef ; // placeholder class defining cgs unit system typedef ; // various unit typedefs for convenience } } }
typedef ; static biot; static biots; } } }
typedef ; static poise; } } }
typedef ; static erg; static ergs; } } }
typedef ; static dyne; static dynes; } } }
(); (); (); (); (); (); (); (); (); (); (); (); (); (); (); (); } }
typedef ; static centimeter; static centimeters; static centimetre; static centimetres; } } }
typedef ; static gram; static grams; static gramme; static grammes; } } }
typedef ; } } }
typedef ; } } }
typedef ; static barye; static baryes; } } }
typedef ; static second; static seconds; } } }
typedef ; static centimeter_per_second; static centimeters_per_second; static centimetre_per_second; static centimetres_per_second; } } }
typedef ; static cubic_centimeter; static cubic_centimeters; static cubic_centimetre; static cubic_centimetres; } } }
typedef ; static kayser; static kaysers; static reciprocal_centimeter; static reciprocal_centimeters; static reciprocal_centimetre; static reciprocal_centimetres; } } }
typedef ; typedef ; typedef ; // angle revolution unit constant static revolution; static revolutions; } } }
template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; template<> struct base_unit_info<>; struct amount_unit_tag; struct current_unit_tag; struct length_unit_tag; struct luminous_intensity_unit_tag; struct mass_unit_tag; struct plane_angle_unit_tag; struct solid_angle_unit_tag; struct temperature_unit_tag; struct time_unit_tag; typedef length_unit_tag, mass_unit_tag, time_unit_tag, current_unit_tag, temperature_unit_tag, amount_unit_tag, luminous_intensity_unit_tag, plane_angle_unit_tag, solid_angle_unit_tag >:: ; typedef ; // abstract unit of length typedef ; // abstract unit of mass typedef ; // abstract unit of time typedef ; // abstract unit of current typedef ; // abstract unit of temperature typedef ; // abstract unit of amount typedef ; // abstract unit of luminous intensity typedef ; // abstract unit of plane angle typedef ; // abstract unit of solid angle } } }
template<> struct base_unit_info<>; typedef degree_base_unit, ; } } }
template<> struct base_unit_info<>; typedef degree_base_unit, ; } } }
struct degree_base_unit; } } }
struct gradian_base_unit; } } }
struct radian_base_unit; } } }
template<> struct base_unit_info<>; typedef degree_base_unit, ; } } }
struct steradian_base_unit; } } }
struct astronomical_unit_base_unit; } } }
template<> struct base_unit_info<>; typedef boost::units::astronomical::light_second_base_unit, ; } } }
template<> struct base_unit_info<>; typedef boost::units::astronomical::light_second_base_unit, ; } } }
template<> struct base_unit_info<>; typedef boost::units::astronomical::light_second_base_unit, ; } } }
struct light_second_base_unit; } } }
template<> struct base_unit_info<>; typedef boost::units::astronomical::light_second_base_unit, ; } } }
struct parsec_base_unit; } } }
typedef ; } } }
struct gram_base_unit; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
struct pint_base_unit; } } }
struct pound_base_unit; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
struct yard_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct are_base_unit; } } }
struct atmosphere_base_unit; } } }
struct bar_base_unit; } } }
struct barn_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct hectare_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct knot_base_unit; } } }
struct liter_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct mmHg_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct torr_base_unit; } } }
template<> struct base_unit_info<>; typedef ; } } }
struct ampere_base_unit; } } }
struct candela_base_unit; } } }
struct kelvin_base_unit; } } }
struct meter_base_unit; } } }
struct mole_base_unit; } } }
struct second_base_unit; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef yard_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
struct pint_base_unit; } } }
struct pound_base_unit; } } }
struct pound_force_base_unit; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pint_base_unit, ; } } }
template<> struct base_unit_info<>; typedef pound_base_unit, ; } } }
struct yard_base_unit; } } }
ampere
angstrom
arcminute
arcsecond
are
astronomical_unit
atmosphere
bar
barn
biot
boost/units/base_units/information/bit.hpp
boost/units/base_units/information/byte.hpp
candela
celsius
centimeter
cup
day
degree
drachm
dram
fahrenheit
fermi
fluid_dram
fluid_ounce
(imperial)
fluid_ounce
(us)
foot
(imperial)
foot
(us)
furlong
gallon (imperial)
gallon (us)
gill (imperial)
gill (us)
gradian
grain (imperial)
grain (us)
gram
boost/units/base_units/information/hartley.hpp
hectare
hour
hundredweight
(imperial)
hundredweight
(us)
inch
(imperial)
inch
(us)
kelvin
kilogram
knot
league
light_day
light_hour
light_minute
light_second
light_year
liter
meter
micron
mil
mile (imperial)
mile (us)
minim
minute
mmHg
mole
boost/units/base_units/information/nat.hpp
nautical_mile
ounce (imperial)
ounce (us)
parsec
pint (imperial)
pint (us)
pound (imperial)
pound (us)
pound_force
quart (imperial)
quart (us)
quarter
radian
revolution
second
boost/units/base_units/information/shannon.hpp
steradian
stone
tablespoon
teaspoon
thou
ton (imperial)
ton (metric)
ton (us)
torr
yard (imperial)
yard (us)
year