Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Reference

Units Reference
Dimensions Reference
SI System Reference
CGS System Reference
Trigonometry and Angle System Reference
Temperature System Reference
Information System Reference
Abstract System Reference
Base Units by Category
Alphabetical Listing of Base Units

Units Reference

Header <boost/units/absolute.hpp>
Header <boost/units/base_dimension.hpp>
Header <boost/units/base_unit.hpp>
Header <boost/units/cmath.hpp>
Header <boost/units/config.hpp>
Header <boost/units/conversion.hpp>
Header <boost/units/derived_dimension.hpp>
Header <boost/units/dim.hpp>
Header <boost/units/dimension.hpp>
Header <boost/units/dimensionless_quantity.hpp>
Header <boost/units/dimensionless_type.hpp>
Header <boost/units/dimensionless_unit.hpp>
Header <boost/units/get_dimension.hpp>
Header <boost/units/get_system.hpp>
Header <boost/units/heterogeneous_system.hpp>
Header <boost/units/homogeneous_system.hpp>
Header <boost/units/io.hpp>
Header <boost/units/is_dim.hpp>
Header <boost/units/is_dimension_list.hpp>
Header <boost/units/is_dimensionless.hpp>
Header <boost/units/is_dimensionless_quantity.hpp>
Header <boost/units/is_dimensionless_unit.hpp>
Header <boost/units/is_quantity.hpp>
Header <boost/units/is_quantity_of_dimension.hpp>
Header <boost/units/is_quantity_of_system.hpp>
Header <boost/units/is_unit.hpp>
Header <boost/units/is_unit_of_dimension.hpp>
Header <boost/units/is_unit_of_system.hpp>
Header <boost/units/lambda.hpp>
Header <boost/units/limits.hpp>
Header <boost/units/make_scaled_unit.hpp>
Header <boost/units/make_system.hpp>
Header <boost/units/operators.hpp>
Header <boost/units/pow.hpp>
Header <boost/units/quantity.hpp>
Header <boost/units/reduce_unit.hpp>
Header <boost/units/scale.hpp>
Header <boost/units/scaled_base_unit.hpp>
Header <boost/units/static_constant.hpp>
Header <boost/units/static_rational.hpp>
Header <boost/units/unit.hpp>
Header <boost/units/units_fwd.hpp>

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 of value_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 of value_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);
  }
}

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-valued static_rational. 
    template< N> 
       (const static_rational< N > &);

    // get string representation of static_rational. 
    template< N,  D> 
       (const static_rational< N, D > &);

    // Write static_rational to std::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 a static_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 the static_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;
  }
}

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 runtime operator==
    template<typename Dim1, typename Dim2, typename System1, typename System2> 
      BOOST_CONSTEXPR bool 
      (const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);

    // unit runtime operator!=
    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.

Dimensions Reference

Header <boost/units/physical_dimensions.hpp>
Header <boost/units/physical_dimensions/absorbed_dose.hpp>
Header <boost/units/physical_dimensions/acceleration.hpp>
Header <boost/units/physical_dimensions/action.hpp>
Header <boost/units/physical_dimensions/activity.hpp>
Header <boost/units/physical_dimensions/amount.hpp>
Header <boost/units/physical_dimensions/angular_acceleration.hpp>
Header <boost/units/physical_dimensions/angular_momentum.hpp>
Header <boost/units/physical_dimensions/angular_velocity.hpp>
Header <boost/units/physical_dimensions/area.hpp>
Header <boost/units/physical_dimensions/capacitance.hpp>
Header <boost/units/physical_dimensions/conductance.hpp>
Header <boost/units/physical_dimensions/conductivity.hpp>
Header <boost/units/physical_dimensions/current.hpp>
Header <boost/units/physical_dimensions/dose_equivalent.hpp>
Header <boost/units/physical_dimensions/dynamic_viscosity.hpp>
Header <boost/units/physical_dimensions/electric_charge.hpp>
Header <boost/units/physical_dimensions/electric_potential.hpp>
Header <boost/units/physical_dimensions/energy.hpp>
Header <boost/units/physical_dimensions/energy_density.hpp>
Header <boost/units/physical_dimensions/force.hpp>
Header <boost/units/physical_dimensions/frequency.hpp>
Header <boost/units/physical_dimensions/heat_capacity.hpp>
Header <boost/units/physical_dimensions/illuminance.hpp>
Header <boost/units/physical_dimensions/impedance.hpp>
Header <boost/units/physical_dimensions/inductance.hpp>
Header <boost/units/physical_dimensions/information.hpp>
Header <boost/units/physical_dimensions/kinematic_viscosity.hpp>
Header <boost/units/physical_dimensions/length.hpp>
Header <boost/units/physical_dimensions/luminance.hpp>
Header <boost/units/physical_dimensions/luminous_flux.hpp>
Header <boost/units/physical_dimensions/luminous_intensity.hpp>
Header <boost/units/physical_dimensions/magnetic_field_intensity.hpp>
Header <boost/units/physical_dimensions/magnetic_flux.hpp>
Header <boost/units/physical_dimensions/magnetic_flux_density.hpp>
Header <boost/units/physical_dimensions/mass.hpp>
Header <boost/units/physical_dimensions/mass_density.hpp>
Header <boost/units/physical_dimensions/molar_energy.hpp>
Header <boost/units/physical_dimensions/molar_heat_capacity.hpp>
Header <boost/units/physical_dimensions/moment_of_inertia.hpp>
Header <boost/units/physical_dimensions/momentum.hpp>
Header <boost/units/physical_dimensions/permeability.hpp>
Header <boost/units/physical_dimensions/permittivity.hpp>
Header <boost/units/physical_dimensions/plane_angle.hpp>
Header <boost/units/physical_dimensions/power.hpp>
Header <boost/units/physical_dimensions/pressure.hpp>
Header <boost/units/physical_dimensions/reluctance.hpp>
Header <boost/units/physical_dimensions/resistance.hpp>
Header <boost/units/physical_dimensions/resistivity.hpp>
Header <boost/units/physical_dimensions/solid_angle.hpp>
Header <boost/units/physical_dimensions/specific_energy.hpp>
Header <boost/units/physical_dimensions/specific_heat_capacity.hpp>
Header <boost/units/physical_dimensions/specific_volume.hpp>
Header <boost/units/physical_dimensions/stress.hpp>
Header <boost/units/physical_dimensions/surface_density.hpp>
Header <boost/units/physical_dimensions/surface_tension.hpp>
Header <boost/units/physical_dimensions/temperature.hpp>
Header <boost/units/physical_dimensions/thermal_conductivity.hpp>
Header <boost/units/physical_dimensions/time.hpp>
Header <boost/units/physical_dimensions/torque.hpp>
Header <boost/units/physical_dimensions/velocity.hpp>
Header <boost/units/physical_dimensions/volume.hpp>
Header <boost/units/physical_dimensions/wavenumber.hpp>

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

SI System Reference

Header <boost/units/systems/si.hpp>
Header <boost/units/systems/si/absorbed_dose.hpp>
Header <boost/units/systems/si/acceleration.hpp>
Header <boost/units/systems/si/action.hpp>
Header <boost/units/systems/si/activity.hpp>
Header <boost/units/systems/si/amount.hpp>
Header <boost/units/systems/si/angular_acceleration.hpp>
Header <boost/units/systems/si/angular_momentum.hpp>
Header <boost/units/systems/si/angular_velocity.hpp>
Header <boost/units/systems/si/area.hpp>
Header <boost/units/systems/si/base.hpp>
Header <boost/units/systems/si/capacitance.hpp>
Header <boost/units/systems/si/catalytic_activity.hpp>
Header <boost/units/systems/si/codata/alpha_constants.hpp>
Header <boost/units/systems/si/codata/atomic-nuclear_constants.hpp>
Header <boost/units/systems/si/codata/deuteron_constants.hpp>
Header <boost/units/systems/si/codata/electromagnetic_constants.hpp>
Header <boost/units/systems/si/codata/electron_constants.hpp>
Header <boost/units/systems/si/codata/helion_constants.hpp>
Header <boost/units/systems/si/codata/muon_constants.hpp>
Header <boost/units/systems/si/codata/neutron_constants.hpp>
Header <boost/units/systems/si/codata/physico-chemical_constants.hpp>
Header <boost/units/systems/si/codata/proton_constants.hpp>
Header <boost/units/systems/si/codata/tau_constants.hpp>
Header <boost/units/systems/si/codata/triton_constants.hpp>
Header <boost/units/systems/si/codata/typedefs.hpp>
Header <boost/units/systems/si/codata/universal_constants.hpp>
Header <boost/units/systems/si/conductance.hpp>
Header <boost/units/systems/si/conductivity.hpp>
Header <boost/units/systems/si/current.hpp>
Header <boost/units/systems/si/dimensionless.hpp>
Header <boost/units/systems/si/dose_equivalent.hpp>
Header <boost/units/systems/si/dynamic_viscosity.hpp>
Header <boost/units/systems/si/electric_charge.hpp>
Header <boost/units/systems/si/electric_potential.hpp>
Header <boost/units/systems/si/energy.hpp>
Header <boost/units/systems/si/force.hpp>
Header <boost/units/systems/si/frequency.hpp>
Header <boost/units/systems/si/illuminance.hpp>
Header <boost/units/systems/si/impedance.hpp>
Header <boost/units/systems/si/inductance.hpp>
Header <boost/units/systems/si/io.hpp>
Header <boost/units/systems/si/kinematic_viscosity.hpp>
Header <boost/units/systems/si/length.hpp>
Header <boost/units/systems/si/luminous_flux.hpp>
Header <boost/units/systems/si/luminous_intensity.hpp>
Header <boost/units/systems/si/magnetic_field_intensity.hpp>
Header <boost/units/systems/si/magnetic_flux.hpp>
Header <boost/units/systems/si/magnetic_flux_density.hpp>
Header <boost/units/systems/si/mass.hpp>
Header <boost/units/systems/si/mass_density.hpp>
Header <boost/units/systems/si/moment_of_inertia.hpp>
Header <boost/units/systems/si/momentum.hpp>
Header <boost/units/systems/si/permeability.hpp>
Header <boost/units/systems/si/permittivity.hpp>
Header <boost/units/systems/si/plane_angle.hpp>
Header <boost/units/systems/si/power.hpp>
Header <boost/units/systems/si/prefixes.hpp>
Header <boost/units/systems/si/pressure.hpp>
Header <boost/units/systems/si/reluctance.hpp>
Header <boost/units/systems/si/resistance.hpp>
Header <boost/units/systems/si/resistivity.hpp>
Header <boost/units/systems/si/solid_angle.hpp>
Header <boost/units/systems/si/surface_density.hpp>
Header <boost/units/systems/si/surface_tension.hpp>
Header <boost/units/systems/si/temperature.hpp>
Header <boost/units/systems/si/time.hpp>
Header <boost/units/systems/si/torque.hpp>
Header <boost/units/systems/si/velocity.hpp>
Header <boost/units/systems/si/volume.hpp>
Header <boost/units/systems/si/wavenumber.hpp>

Includes all the si unit headers


  
    
      typedef  ;

      static  gray;
      static  grays;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  becquerel;
      static  becquerels;
    }
  }
}

  
    
      typedef  ;

      static  mole;
      static  moles;
    }
  }
}

  
    
      typedef  ;

      static  square_meter;
      static  square_meters;
      static  square_metre;
      static  square_metres;
    }
  }
}

  
    
      typedef  ;  // placeholder class defining si unit system 
      typedef  ;  // dimensionless si unit 
    }
  }
}

  
    
      typedef  ;

      static  farad;
      static  farads;
    }
  }
}

  
    
      typedef  ;  // catalytic activity : T^-1 A^1 
      typedef  ;

      static  katal;
      static  katals;
    }
  }
}

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  siemen;
      static  siemens;
      static  mho;
      static  mhos;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  ampere;
      static  amperes;
    }
  }
}

  
    
      typedef  ;

      static  sievert;
      static  sieverts;
    }
  }
}

  
    
      typedef  ;

      static  coulomb;
      static  coulombs;
    }
  }
}

  
    
      typedef  ;

      static  volt;
      static  volts;
    }
  }
}

  
    
      typedef  ;

      static  joule;
      static  joules;
    }
  }
}

  
    
      typedef  ;

      static  newton;
      static  newtons;
    }
  }
}

  
    
      typedef  ;

      static  hertz;
    }
  }
}

  
    
      typedef  ;

      static  lux;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  henry;
      static  henrys;
    }
  }
}

  
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
  }
}

  
    
      typedef  ;

      static  meter;
      static  meters;
      static  metre;
      static  metres;
    }
  }
}

  
    
      typedef  ;

      static  lumen;
      static  lumens;
    }
  }
}

  
    
      typedef  ;

      static  candela;
      static  candelas;
    }
  }
}

  
    
      typedef  ;

      static  weber;
      static  webers;
    }
  }
}

  
    
      typedef  ;

      static  tesla;
      static  teslas;
    }
  }
}

  
    
      typedef  ;

      static  kilogram;
      static  kilograms;
      static  kilogramme;
      static  kilogrammes;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  radian;
      static  radians;
    }
  }
}

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

  
    
      typedef  ;

      static  ohm;
      static  ohms;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  steradian;
      static  steradians;
    }
  }
}

  
    
      typedef  ;

      static  kelvin;
      static  kelvins;
    }
  }
}

  
    
      typedef  ;

      static  second;
      static  seconds;
    }
  }
}

  
    
      typedef  ;

      static  newton_meter;
      static  newton_meters;
    }
  }
}

  
    
      typedef  ;

      static  cubic_meter;
      static  cubic_meters;
      static  cubic_metre;
      static  cubic_metres;
    }
  }
}

CGS System Reference

Includes all the cgs unit headers


  
    
      typedef  ;

      static  gal;
      static  gals;
    }
  }
}

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

  
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
     ();
  }
}

  
    
      typedef  ;

      static  stoke;
      static  stokes;
    }
  }
}

  
    
      typedef  ;

      static  centimeter;
      static  centimeters;
      static  centimetre;
      static  centimetres;
    }
  }
}

  
    
      typedef  ;

      static  gram;
      static  grams;
      static  gramme;
      static  grammes;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;
    }
  }
}

  
    
      typedef  ;

      static  barye;
      static  baryes;
    }
  }
}

  
    
      typedef  ;

      static  second;
      static  seconds;
    }
  }
}

Trigonometry and Angle System Reference


  
    
      typedef  ;
      typedef  ;
      typedef  ;  // angle degree unit constant 

      static  degree;
      static  degrees;
    }
  }
}

  
    
      typedef  ;
      typedef  ;
      typedef  ;  // angle gradian unit constant 

      static  gradian;
      static  gradians;
    }
  }
}

  
    
      typedef  ;
      typedef  ;
      typedef  ;  // angle revolution unit constant 

      static  revolution;
      static  revolutions;
    }
  }
}

Temperature System Reference


  
    
      typedef  ;
      typedef  ;

      static  degree;
      static  degrees;
    }
  }
}

  
    
      typedef  ;
      typedef  ;

      static  degree;
      static  degrees;
    }
  }
}

Information System Reference


  
    
      static  bit;
      static  bits;
      
        
          typedef  ;
        }
      }
    }
  }
}

  
    
      typedef  ;
      typedef  ;
      typedef  ;

      static  byte;
      static  bytes;
      
        
          typedef  ;
        }
      }
    }
  }
}

  
    
      static  hartley;
      static  hartleys;
      
        
          typedef  ;
        }
      }
    }
  }
}

  
    
      static  nat;
      static  nats;
      
        
          typedef  ;
        }
      }
    }
  }
}

  
    
      static  shannon;
      static  shannons;
      
        
          typedef  ;
        }
      }
    }
  }
}

Abstract System Reference


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

Imperial Base Units Reference


  
    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 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,  ;
    }
  }
}

  
    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,  ;
    }
  }
}

Metric Base Units Reference


  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

  
    template<> struct base_unit_info<>;
    
      typedef  ;
    }
  }
}

US Base Units Reference


  
    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,  ;
    }
  }
}

  
    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,  ;
    }
  }
}

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


PrevUpHomeNext