From 733b5d5ae2c5d625211e2985ac25728ac3f54883 Mon Sep 17 00:00:00 2001 From: DongHun Kwak Date: Mon, 21 Mar 2016 15:45:20 +0900 Subject: Imported Upstream version 1.58.0 Change-Id: If0072143aa26874812e0db6872e1efb10a3e5e94 Signed-off-by: DongHun Kwak --- doc/html/boost_units/Quantities.html | 10 +- doc/html/boost_units/Reference.html | 1116 +++++++++++++++++++--------------- doc/html/boost_units/Units.html | 2 +- doc/html/boost_units/version_id.html | 2 +- 4 files changed, 619 insertions(+), 511 deletions(-) (limited to 'doc/html/boost_units') diff --git a/doc/html/boost_units/Quantities.html b/doc/html/boost_units/Quantities.html index 1b18334e61..d0036478ee 100644 --- a/doc/html/boost_units/Quantities.html +++ b/doc/html/boost_units/Quantities.html @@ -57,8 +57,8 @@ Operators +, -, *, and / are provided for algebraic operations between scalars and units, scalars and quantities, units and quantities, and between quantities. In addition, integral and rational powers and roots can be computed using the - pow<R> - and root<R> + pow<R> + and root<R> functions. Finally, the standard set of boolean comparison operators ( ==, !=, <, <=, >, and >= @@ -171,9 +171,9 @@ This library is designed to emphasize safety above convenience when performing operations with dimensioned quantities. Specifically, construction of quantities is required to fully specify both value and unit. Direct construction from - a scalar value is prohibited (though the static member function from_value + a scalar value is prohibited (though the static member function from_value is provided to enable this functionality where it is necessary. In addition, - a quantity_cast + a quantity_cast to a reference allows direct access to the underlying value of a quantity variable. An explicit constructor is provided to enable conversion between dimensionally compatible quantities in different unit systems. Implicit conversions @@ -222,7 +222,7 @@
  • quantity<Unit,Y> can be directly constructed from a value of type Y - using the static member function from_value. + using the static member function from_value. Doing so, naturally, bypasses any type-checking of the newly assigned value, so this method should be used only when absolutely necessary.
    • diff --git a/doc/html/boost_units/Reference.html b/doc/html/boost_units/Reference.html index f6107a43f4..5ee0255f68 100644 --- a/doc/html/boost_units/Reference.html +++ b/doc/html/boost_units/Reference.html @@ -33,6 +33,7 @@
    CGS System Reference
    Trigonometry and Angle System Reference
    Temperature System Reference
    +
    Information System Reference
    Abstract System Reference
    Base Units by Category
    @@ -100,34 +101,34 @@ // add a relative value to an absolute one template<typename Y> - absolute< Y > operator+(const absolute< Y > & aval, const Y & rval); + absolute< Y > operator+(const absolute< Y > & aval, const Y & rval); // add a relative value to an absolute one template<typename Y> - absolute< Y > operator+(const Y & rval, const absolute< Y > & aval); + absolute< Y > operator+(const Y & rval, const absolute< Y > & aval); // subtract a relative value from an absolute one template<typename Y> - absolute< Y > operator-(const absolute< Y > & aval, const Y & rval); + absolute< Y > operator-(const absolute< Y > & aval, const Y & rval); // subtracting two absolutes gives a difference template<typename Y> - Y operator-(const absolute< Y > & aval1, const absolute< Y > & aval2); + Y operator-(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> quantity< absolute< unit< D, S > >, T > - operator*(const T & t, const absolute< unit< D, S > > &); + operator*(const T & t, const absolute< unit< D, S > > &); // creates a quantity from an absolute unit and a raw value template<typename D, typename S, typename T> quantity< absolute< unit< D, S > >, T > - operator*(const absolute< unit< D, S > > &, const T & t); + operator*(const absolute< unit< D, S > > &, const T & t); // Print an absolute unit. template<typename Char, typename Traits, typename Y> std::basic_ostream< Char, Traits > & - operator<<(std::basic_ostream< Char, Traits > & os, + operator<<(std::basic_ostream< Char, Traits > & os, const absolute< Y > & aval); } } @@ -236,7 +237,7 @@ quantity< Unit, Y > frexp(const quantity< Unit, Y > & q, Int * ex); template<typename S, typename Y> quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > - pow(const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &, + pow(const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &, const quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > &); template<typename S, typename Y> quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y > @@ -256,73 +257,73 @@ // cos of theta in radians template<typename Y> dimensionless_quantity< si::system, Y >::type - cos(const quantity< si::plane_angle, Y > & theta); + cos(const quantity< si::plane_angle, Y > & theta); // sin of theta in radians template<typename Y> dimensionless_quantity< si::system, Y >::type - sin(const quantity< si::plane_angle, Y > & theta); + sin(const quantity< si::plane_angle, Y > & theta); // tan of theta in radians template<typename Y> dimensionless_quantity< si::system, Y >::type - tan(const quantity< si::plane_angle, Y > & theta); + tan(const quantity< si::plane_angle, Y > & theta); // cos of theta in other angular units template<typename System, typename Y> dimensionless_quantity< System, Y >::type - cos(const quantity< unit< plane_angle_dimension, System >, Y > & theta); + cos(const quantity< unit< plane_angle_dimension, System >, Y > & theta); // sin of theta in other angular units template<typename System, typename Y> dimensionless_quantity< System, Y >::type - sin(const quantity< unit< plane_angle_dimension, System >, Y > & theta); + sin(const quantity< unit< plane_angle_dimension, System >, Y > & theta); // tan of theta in other angular units template<typename System, typename Y> dimensionless_quantity< System, Y >::type - tan(const quantity< unit< plane_angle_dimension, System >, Y > & theta); + tan(const quantity< unit< plane_angle_dimension, System >, Y > & theta); // acos of dimensionless quantity returning angle in same system template<typename Y, typename System> quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > - acos(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); + acos(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // acos of dimensionless quantity returning angle in radians template<typename Y> quantity< angle::radian_base_unit::unit_type, Y > - acos(const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); + acos(const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); // asin of dimensionless quantity returning angle in same system template<typename Y, typename System> quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > - asin(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); + asin(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // asin of dimensionless quantity returning angle in radians template<typename Y> quantity< angle::radian_base_unit::unit_type, Y > - asin(const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); + asin(const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); // atan of dimensionless quantity returning angle in same system template<typename Y, typename System> quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > - atan(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); + atan(const quantity< unit< dimensionless_type, homogeneous_system< System > >, Y > & val); // atan of dimensionless quantity returning angle in radians template<typename Y> quantity< angle::radian_base_unit::unit_type, Y > - atan(const quantity< unit< dimensionless_type, heterogeneous_dimensionless_system >, Y > & val); + atan(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> quantity< unit< plane_angle_dimension, homogeneous_system< System > >, Y > - atan2(const quantity< unit< Dimension, homogeneous_system< System > >, Y > & y, + atan2(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> quantity< angle::radian_base_unit::unit_type, Y > - atan2(const quantity< unit< Dimension, heterogeneous_system< System > >, Y > & y, + atan2(const quantity< unit< Dimension, heterogeneous_system< System > >, Y > & y, const quantity< unit< Dimension, heterogeneous_system< System > >, Y > & x); } } @@ -390,8 +391,6 @@ 
    namespace boost {
   namespace units {
     template<typename Seq> struct make_dimension_list;
-    template<typename DL, typename Ex> struct static_power;
-    template<typename DL, typename Rt> struct static_root;
   }
 }
    @@ -433,11 +432,11 @@ namespace units { template<typename T> struct get_dimension; - template<typename Dim, typename System> - struct get_dimension<unit< Dim, System >>; - template<typename Unit> struct get_dimension<absolute< Unit >>; + template<typename Unit> struct get_dimension<absolute< Unit >>; template<typename Unit, typename Y> - struct get_dimension<quantity< Unit, Y >>; + struct get_dimension<quantity< Unit, Y >>; + template<typename Dim, typename System> + struct get_dimension<unit< Dim, System >>; } } @@ -449,10 +448,10 @@ namespace units { template<typename T> struct get_system; + template<typename Unit> struct get_system<absolute< Unit >>; + template<typename Unit, typename Y> struct get_system<quantity< Unit, Y >>; template<typename Dim, typename System> - struct get_system<unit< Dim, System >>; - template<typename Unit> struct get_system<absolute< Unit >>; - template<typename Unit, typename Y> struct get_system<quantity< Unit, Y >>; + struct get_system<unit< Dim, System >>; } } @@ -474,6 +473,8 @@ 
    namespace boost {
   namespace units {
     template<typename L> struct homogeneous_system;
+    template<typename DL, typename Ex> struct static_power;
+    template<typename DL, typename Rt> struct static_root;
   }
 }
    @@ -487,12 +488,12 @@ // Boost Serialization library support for units. template<typename Archive, typename System, typename Dim> - void serialize(Archive & ar, boost::units::unit< Dim, System > &, + void serialize(Archive & ar, boost::units::unit< Dim, System > &, const unsigned int); // Boost Serialization library support for quantities. template<typename Archive, typename Unit, typename Y> - void serialize(Archive & ar, boost::units::quantity< Unit, Y > & q, + void serialize(Archive & ar, boost::units::quantity< Unit, Y > & q, const unsigned int); } namespace units { @@ -506,20 +507,20 @@ enum autoprefix_mode { autoprefix_none = = 0, autoprefix_engineering = = 4, autoprefix_binary = = 8, autoprefix_mask = = 12 }; - template<typename T> std::string to_string(const T & t); + template<typename T> std::string to_string(const T & t); // get string representation of integral-valued static_rational. template<integer_type N> - std::string to_string(const static_rational< N > &); + std::string to_string(const static_rational< N > &); // get string representation of static_rational. template<integer_type N, integer_type D> - std::string to_string(const static_rational< N, D > &); + std::string to_string(const static_rational< N, D > &); // Write static_rational to std::basic_ostream. template<typename Char, typename Traits, integer_type N, integer_type D> std::basic_ostream< Char, Traits > & - operator<<(std::basic_ostream< Char, Traits > & os, + operator<<(std::basic_ostream< Char, Traits > & os, const static_rational< N, D > & r); // returns flags controlling output. @@ -564,17 +565,17 @@ template<typename Dimension, typename System> std::string typename_string(const unit< Dimension, System > &); template<typename Dimension, typename System> - std::string symbol_string(const unit< Dimension, System > &); + std::string symbol_string(const unit< Dimension, System > &); template<typename Dimension, typename System> - std::string name_string(const unit< Dimension, System > &); + std::string name_string(const unit< Dimension, System > &); template<typename Char, typename Traits, typename Dimension, typename System> std::basic_ostream< Char, Traits > & - operator<<(std::basic_ostream< Char, Traits > &, + operator<<(std::basic_ostream< Char, Traits > &, const unit< Dimension, System > &); template<typename Char, typename Traits, typename Unit, typename T> std::basic_ostream< Char, Traits > & - operator<<(std::basic_ostream< Char, Traits > &, + operator<<(std::basic_ostream< Char, Traits > &, const quantity< Unit, T > &); } } @@ -587,7 +588,7 @@ namespace units { template<typename T> struct is_dim; - template<typename T, typename V> struct is_dim<dim< T, V >>; + template<typename T, typename V> struct is_dim<dim< T, V >>; } } @@ -599,9 +600,9 @@ namespace units { template<typename Seq> struct is_dimension_list; + template<> struct is_dimension_list<dimensionless_type>; template<typename Item, typename Next> - struct is_dimension_list<list< Item, Next >>; - template<> struct is_dimension_list<dimensionless_type>; + struct is_dimension_list<list< Item, Next >>; } } @@ -613,10 +614,10 @@ namespace units { template<typename T> struct is_dimensionless; - template<typename System> - struct is_dimensionless<unit< dimensionless_type, System >>; template<typename Unit, typename Y> - struct is_dimensionless<quantity< Unit, Y >>; + struct is_dimensionless<quantity< Unit, Y >>; + template<typename System> + struct is_dimensionless<unit< dimensionless_type, System >>; } } @@ -648,7 +649,7 @@ namespace units { template<typename T> struct is_quantity; - template<typename Unit, typename Y> struct is_quantity<quantity< Unit, Y >>; + template<typename Unit, typename Y> struct is_quantity<quantity< Unit, Y >>; } } @@ -661,7 +662,7 @@ template<typename T, typename Dim> struct is_quantity_of_dimension; template<typename Unit, typename Y, typename Dim> - struct is_quantity_of_dimension<quantity< Unit, Y >, Dim>; + struct is_quantity_of_dimension<quantity< Unit, Y >, Dim>; } } @@ -674,7 +675,7 @@ template<typename T, typename System> struct is_quantity_of_system; template<typename Unit, typename Y, typename System> - struct is_quantity_of_system<quantity< Unit, Y >, System>; + struct is_quantity_of_system<quantity< Unit, Y >, System>; } } @@ -686,7 +687,7 @@ namespace units { template<typename T> struct is_unit; - template<typename Dim, typename System> struct is_unit<unit< Dim, System >>; + template<typename Dim, typename System> struct is_unit<unit< Dim, System >>; } } @@ -699,9 +700,9 @@ template<typename T, typename Dim> struct is_unit_of_dimension; template<typename Dim, typename System> - struct is_unit_of_dimension<unit< Dim, System >, Dim>; + struct is_unit_of_dimension<absolute< unit< Dim, System > >, Dim>; template<typename Dim, typename System> - struct is_unit_of_dimension<absolute< unit< Dim, System > >, Dim>; + struct is_unit_of_dimension<unit< Dim, System >, Dim>; } } @@ -714,9 +715,9 @@ template<typename T, typename System> struct is_unit_of_system; template<typename Dim, typename System> - struct is_unit_of_system<unit< Dim, System >, System>; + struct is_unit_of_system<absolute< unit< Dim, System > >, System>; template<typename Dim, typename System> - struct is_unit_of_system<absolute< unit< Dim, System > >, System>; + struct is_unit_of_system<unit< Dim, System >, System>; } } @@ -732,111 +733,111 @@ 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. 

    namespace boost {
   namespace lambda {
-    template<typename System, typename Dim, typename Y> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim, System >, Y>;
-    template<typename System, typename Dim, typename Y> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim, System >, Y>;
-    template<typename System, typename Dim, typename Y> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, Y, boost::units::unit< Dim, System >>;
-    template<typename System, typename Dim, typename Y> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, Y, boost::units::unit< Dim, System >>;
-    template<typename Unit, typename X> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit, X >, X>;
-    template<typename Unit, typename X> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, X, boost::units::quantity< Unit, X >>;
-    template<typename Unit, typename X> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit, X >, X>;
-    template<typename Unit, typename X> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, X, boost::units::quantity< Unit, X >>;
-    template<typename System1, typename Dim1, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim1, System1 >, boost::units::quantity< Unit2, Y >>;
-    template<typename System1, typename Dim1, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim1, System1 >, boost::units::quantity< Unit2, Y >>;
-    template<typename Unit1, typename Y, typename System2, typename Dim2> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit1, Y >, boost::units::unit< Dim2, System2 >>;
-    template<typename Unit1, typename Y, typename System2, typename Dim2> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit1, Y >, boost::units::unit< Dim2, System2 >>;
     template<typename Unit, typename Y> 
-      struct plain_return_type_1<unary_arithmetic_action< plus_action >, boost::units::quantity< Unit, Y >>;
+      struct plain_return_type_1<unary_arithmetic_action< minus_action >, boost::units::quantity< Unit, Y >>;
+    template<typename Dim, typename System> 
+      struct plain_return_type_1<unary_arithmetic_action< minus_action >, boost::units::unit< Dim, System >>;
     template<typename Unit, typename Y> 
-      struct plain_return_type_1<unary_arithmetic_action< minus_action >, boost::units::quantity< Unit, Y >>;
+      struct plain_return_type_1<unary_arithmetic_action< plus_action >, boost::units::quantity< Unit, Y >>;
+    template<typename Dim, typename System> 
+      struct plain_return_type_1<unary_arithmetic_action< plus_action >, boost::units::unit< Dim, System >>;
+    template<typename Unit, typename X> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit, X >, X>;
     template<typename Unit1, typename X, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
-    template<typename System, typename X, typename Y> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y>;
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
+    template<typename Unit1, typename Y, typename System2, typename Dim2> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit1, Y >, boost::units::unit< Dim2, System2 >>;
+    template<typename System, typename Dim, typename Y> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim, System >, Y>;
+    template<typename System1, typename Dim1, typename Unit2, typename Y> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim1, System1 >, boost::units::quantity< Unit2, Y >>;
+    template<typename Dim1, typename Dim2, typename System1, typename System2> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
+    template<typename Unit, typename X> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, X, boost::units::quantity< Unit, X >>;
+    template<typename System, typename Dim, typename Y> 
+      struct plain_return_type_2<arithmetic_action< divide_action >, Y, boost::units::unit< Dim, System >>;
+    template<typename Y> 
+      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::absolute< Y >, boost::units::absolute< Y >>;
+    template<typename Y> 
+      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::absolute< Y >, Y>;
     template<typename System, typename X, typename Y> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, X, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y >>;
+      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y>;
     template<typename Unit1, typename X, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
-    template<typename System, typename X, typename Y> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y>;
+      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
+    template<typename Dim1, typename Dim2, typename System1, typename System2> 
+      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
     template<typename System, typename X, typename Y> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, X, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y >>;
-    template<typename Unit1, typename X, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
+      struct plain_return_type_2<arithmetic_action< minus_action >, X, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y >>;
+    template<typename D, typename S, typename T> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::absolute< boost::units::unit< D, S > >, T>;
+    template<typename Unit, typename X> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit, X >, X>;
     template<typename Unit1, typename X, typename Unit2, typename Y> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
-    template<typename Dim, typename System> 
-      struct plain_return_type_1<unary_arithmetic_action< plus_action >, boost::units::unit< Dim, System >>;
-    template<typename Dim, typename System> 
-      struct plain_return_type_1<unary_arithmetic_action< minus_action >, boost::units::unit< Dim, System >>;
-    template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
-    template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
-    template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
+    template<typename Unit1, typename Y, typename System2, typename Dim2> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::quantity< Unit1, Y >, boost::units::unit< Dim2, System2 >>;
+    template<typename System, typename Dim, typename Y> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim, System >, Y>;
+    template<typename System1, typename Dim1, typename Unit2, typename Y> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim1, System1 >, boost::units::quantity< Unit2, Y >>;
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      struct plain_return_type_2<arithmetic_action< divide_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
-    template<typename Y> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::absolute< Y >, Y>;
-    template<typename Y> 
-      struct plain_return_type_2<arithmetic_action< plus_action >, Y, boost::units::absolute< Y >>;
+      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
+    template<typename D, typename S, typename T> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, T, boost::units::absolute< boost::units::unit< D, S > >>;
+    template<typename Unit, typename X> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, X, boost::units::quantity< Unit, X >>;
+    template<typename System, typename Dim, typename Y> 
+      struct plain_return_type_2<arithmetic_action< multiply_action >, Y, boost::units::unit< Dim, System >>;
     template<typename Y> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::absolute< Y >, Y>;
+      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::absolute< Y >, Y>;
+    template<typename System, typename X, typename Y> 
+      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), X >, Y>;
+    template<typename Unit1, typename X, typename Unit2, typename Y> 
+      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::quantity< Unit1, X >, boost::units::quantity< Unit2, Y >>;
+    template<typename Dim1, typename Dim2, typename System1, typename System2> 
+      struct plain_return_type_2<arithmetic_action< plus_action >, boost::units::unit< Dim1, System1 >, boost::units::unit< Dim2, System2 >>;
+    template<typename System, typename X, typename Y> 
+      struct plain_return_type_2<arithmetic_action< plus_action >, X, boost::units::quantity< BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y >>;
     template<typename Y> 
-      struct plain_return_type_2<arithmetic_action< minus_action >, boost::units::absolute< Y >, boost::units::absolute< Y >>;
-    template<typename D, typename S, typename T> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, T, boost::units::absolute< boost::units::unit< D, S > >>;
-    template<typename D, typename S, typename T> 
-      struct plain_return_type_2<arithmetic_action< multiply_action >, boost::units::absolute< boost::units::unit< D, S > >, T>;
+      struct plain_return_type_2<arithmetic_action< plus_action >, Y, boost::units::absolute< Y >>;
   }
   namespace units {
     template<typename System, typename Dim, typename Arg> 
-      struct multiply_typeof_helper<boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg >>;
+      struct divide_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System >>;
     template<typename System, typename Dim, typename Arg> 
-      struct divide_typeof_helper<boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg >>;
+      struct divide_typeof_helper<boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg >>;
     template<typename System, typename Dim, typename Arg> 
-      struct multiply_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System >>;
+      struct multiply_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::absolute< boost::units::unit< Dim, System > >>;
     template<typename System, typename Dim, typename Arg> 
-      struct divide_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System >>;
+      struct multiply_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System >>;
     template<typename System, typename Dim, typename Arg> 
-      struct multiply_typeof_helper<boost::lambda::lambda_functor< Arg >, boost::units::absolute< boost::units::unit< Dim, System > >>;
+      struct multiply_typeof_helper<boost::units::absolute< boost::units::unit< Dim, System > >, boost::lambda::lambda_functor< Arg >>;
     template<typename System, typename Dim, typename Arg> 
-      struct multiply_typeof_helper<boost::units::absolute< boost::units::unit< Dim, System > >, boost::lambda::lambda_functor< Arg >>;
+      struct multiply_typeof_helper<boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg >>;
     template<typename System, typename Dim, typename Arg> 
       const multiply_typeof_helper< boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg > >::type 
-      operator*(const boost::units::unit< Dim, System > &, 
+      operator*(const boost::units::unit< Dim, System > &, 
                 const boost::lambda::lambda_functor< Arg > &);
     template<typename System, typename Dim, typename Arg> 
       const divide_typeof_helper< boost::units::unit< Dim, System >, boost::lambda::lambda_functor< Arg > >::type 
-      operator/(const boost::units::unit< Dim, System > &, 
+      operator/(const boost::units::unit< Dim, System > &, 
                 const boost::lambda::lambda_functor< Arg > &);
     template<typename System, typename Dim, typename Arg> 
       const multiply_typeof_helper< boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System > >::type 
-      operator*(const boost::lambda::lambda_functor< Arg > &, 
+      operator*(const boost::lambda::lambda_functor< Arg > &, 
                 const boost::units::unit< Dim, System > &);
     template<typename System, typename Dim, typename Arg> 
       const divide_typeof_helper< boost::lambda::lambda_functor< Arg >, boost::units::unit< Dim, System > >::type 
-      operator/(const boost::lambda::lambda_functor< Arg > &, 
+      operator/(const boost::lambda::lambda_functor< Arg > &, 
                 const boost::units::unit< Dim, System > &);
     template<typename System, typename Dim, typename Arg> 
       const multiply_typeof_helper< boost::lambda::lambda_functor< Arg >, boost::units::absolute< boost::units::unit< Dim, System > > >::type 
-      operator*(const boost::lambda::lambda_functor< Arg > &, 
+      operator*(const boost::lambda::lambda_functor< 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 > >, boost::lambda::lambda_functor< Arg > >::type 
-      operator*(const boost::units::absolute< boost::units::unit< Dim, System > > &, 
+      operator*(const boost::units::absolute< boost::units::unit< Dim, System > > &, 
                 const boost::lambda::lambda_functor< Arg > &);
   }
 }
    @@ -847,7 +848,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni

    specialize std::numeric_limits for units. 

    namespace std {
   template<typename Unit, typename T> 
-    class numeric_limits<::boost::units::quantity< Unit, T >>;
+    class numeric_limits<::boost::units::quantity< Unit, T >>;
 }
    @@ -859,10 +860,10 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni template<typename Dimension, typename UnitList, typename OldScale, typename Scale> - struct make_scaled_unit<unit< Dimension, heterogeneous_system< heterogeneous_system_impl< UnitList, Dimension, OldScale > > >, Scale>; + struct make_scaled_unit<unit< Dimension, heterogeneous_system< heterogeneous_system_impl< UnitList, Dimension, OldScale > > >, Scale>; template<typename Dimension, typename UnitList, typename OldScale, long Base> - struct make_scaled_unit<unit< Dimension, heterogeneous_system< heterogeneous_system_impl< UnitList, Dimension, OldScale > > >, scale< Base, static_rational< 0 > >>; + struct make_scaled_unit<unit< Dimension, heterogeneous_system< heterogeneous_system_impl< UnitList, Dimension, OldScale > > >, scale< Base, static_rational< 0 > >>; } }
    @@ -886,14 +887,14 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni

    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. 

    namespace boost {
   namespace units {
-    template<typename X> struct unary_plus_typeof_helper;
-    template<typename X> struct unary_minus_typeof_helper;
     template<typename X, typename Y> struct add_typeof_helper;
-    template<typename X, typename Y> struct subtract_typeof_helper;
-    template<typename X, typename Y> struct multiply_typeof_helper;
     template<typename X, typename Y> struct divide_typeof_helper;
-    template<typename X, typename Y> struct power_typeof_helper;
-    template<typename X, typename Y> struct root_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;
   }
 }
    @@ -906,19 +907,19 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni // raise a value to a static_rational power. template<typename Rat, typename Y> - power_typeof_helper< Y, Rat >::type pow(const Y & x); + power_typeof_helper< Y, Rat >::type pow(const Y & x); // raise a value to an integer power. template<long N, typename Y> - power_typeof_helper< Y, static_rational< N > >::type pow(const Y & x); + power_typeof_helper< Y, static_rational< N > >::type pow(const Y & x); // take the static_rational root of a value. template<typename Rat, typename Y> - root_typeof_helper< Y, Rat >::type root(const Y & x); + root_typeof_helper< Y, Rat >::type root(const Y & x); // take the integer root of a value. template<long N, typename Y> - root_typeof_helper< Y, static_rational< N > >::type root(const Y & x); + root_typeof_helper< Y, static_rational< N > >::type root(const Y & x); } } @@ -927,151 +928,152 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/quantity.hpp> 
    namespace boost {
   namespace units {
+    template<typename Dim, typename System, typename X, typename Y> 
+      struct add_typeof_helper<quantity< unit< Dim, System >, X >, quantity< unit< Dim, System >, Y >>;
+    template<typename Dim1, typename System1, typename Dim2, typename System2, 
+             typename X, typename Y> 
+      struct add_typeof_helper<quantity< unit< Dim1, System1 >, X >, quantity< unit< Dim2, System2 >, Y >>;
+
     template<typename Unit, typename Y> class quantity;
 
     template<typename System, typename Y> 
-      class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y>;
+      class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y>;
 
-    template<typename Dim1, typename System1, typename Dim2, typename System2, 
-             typename X, typename Y> 
-      struct add_typeof_helper<quantity< unit< Dim1, System1 >, X >, quantity< unit< Dim2, System2 >, Y >>;
     template<typename Dim, typename System, typename X, typename Y> 
-      struct add_typeof_helper<quantity< unit< Dim, System >, X >, quantity< unit< Dim, System >, Y >>;
+      struct subtract_typeof_helper<quantity< unit< Dim, System >, X >, quantity< unit< Dim, System >, Y >>;
     template<typename Dim1, typename System1, typename Dim2, typename System2, 
              typename X, typename Y> 
-      struct subtract_typeof_helper<quantity< unit< Dim1, System1 >, X >, quantity< unit< Dim2, System2 >, Y >>;
-    template<typename Dim, typename System, typename X, typename Y> 
-      struct subtract_typeof_helper<quantity< unit< Dim, System >, X >, quantity< unit< Dim, System >, Y >>;
+      struct subtract_typeof_helper<quantity< unit< Dim1, System1 >, X >, quantity< unit< Dim2, System2 >, Y >>;
 
     // quantity_cast provides mutating access to underlying quantity value_type 
-    template<typename X, typename Y> X quantity_cast(Y & source);
-    template<typename X, typename Y> X quantity_cast(const Y & source);
+    template<typename X, typename Y> X quantity_cast(Y & source);
+    template<typename X, typename Y> X quantity_cast(const Y & source);
 
     // swap quantities 
     template<typename Unit, typename Y> 
-      void swap(quantity< Unit, Y > & lhs, quantity< Unit, Y > & rhs);
+      void swap(quantity< Unit, Y > & lhs, quantity< Unit, Y > & rhs);
 
     // runtime unit divided by scalar 
     template<typename System, typename Dim, typename Y> 
       divide_typeof_helper< unit< Dim, System >, Y >::type 
-      operator/(const unit< Dim, System > &, const Y & rhs);
+      operator/(const unit< Dim, System > &, const Y & rhs);
 
     // runtime scalar times unit 
     template<typename System, typename Dim, typename Y> 
       multiply_typeof_helper< Y, unit< Dim, System > >::type 
-      operator*(const Y & lhs, const unit< Dim, System > &);
+      operator*(const Y & lhs, const unit< Dim, System > &);
 
     // runtime scalar divided by unit 
     template<typename System, typename Dim, typename Y> 
       divide_typeof_helper< Y, unit< Dim, System > >::type 
-      operator/(const Y & lhs, const unit< Dim, System > &);
+      operator/(const Y & lhs, const unit< Dim, System > &);
 
     // runtime quantity times scalar 
     template<typename Unit, typename X> 
       multiply_typeof_helper< quantity< Unit, X >, X >::type 
-      operator*(const quantity< Unit, X > & lhs, const X & rhs);
+      operator*(const quantity< Unit, X > & lhs, const X & rhs);
 
     // runtime scalar times quantity 
     template<typename Unit, typename X> 
       multiply_typeof_helper< X, quantity< Unit, X > >::type 
-      operator*(const X & lhs, const quantity< Unit, X > & rhs);
+      operator*(const X & lhs, const quantity< Unit, X > & rhs);
 
     // runtime quantity divided by scalar 
     template<typename Unit, typename X> 
       divide_typeof_helper< quantity< Unit, X >, X >::type 
-      operator/(const quantity< Unit, X > & lhs, const X & rhs);
+      operator/(const quantity< Unit, X > & lhs, const X & rhs);
 
     // runtime scalar divided by quantity 
     template<typename Unit, typename X> 
       divide_typeof_helper< X, quantity< Unit, X > >::type 
-      operator/(const X & lhs, const quantity< Unit, X > & rhs);
+      operator/(const X & lhs, const quantity< Unit, X > & rhs);
 
     // runtime unit times quantity 
     template<typename System1, typename Dim1, typename Unit2, typename Y> 
       multiply_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >::type 
-      operator*(const unit< Dim1, System1 > &, 
+      operator*(const unit< Dim1, System1 > &, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime unit divided by quantity 
     template<typename System1, typename Dim1, typename Unit2, typename Y> 
       divide_typeof_helper< unit< Dim1, System1 >, quantity< Unit2, Y > >::type 
-      operator/(const unit< Dim1, System1 > &, 
+      operator/(const unit< Dim1, System1 > &, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime quantity times unit 
     template<typename Unit1, typename System2, typename Dim2, typename Y> 
       multiply_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >::type 
-      operator*(const quantity< Unit1, Y > & lhs, 
+      operator*(const quantity< Unit1, Y > & lhs, 
                 const unit< Dim2, System2 > &);
 
     // runtime quantity divided by unit 
     template<typename Unit1, typename System2, typename Dim2, typename Y> 
       divide_typeof_helper< quantity< Unit1, Y >, unit< Dim2, System2 > >::type 
-      operator/(const quantity< Unit1, Y > & lhs, 
+      operator/(const quantity< Unit1, Y > & lhs, 
                 const unit< Dim2, System2 > &);
 
     // runtime unary plus quantity 
     template<typename Unit, typename Y> 
       unary_plus_typeof_helper< quantity< Unit, Y > >::type 
-      operator+(const quantity< Unit, Y > & val);
+      operator+(const quantity< Unit, Y > & val);
 
     // runtime unary minus quantity 
     template<typename Unit, typename Y> 
       unary_minus_typeof_helper< quantity< Unit, Y > >::type 
-      operator-(const quantity< Unit, Y > & val);
+      operator-(const quantity< Unit, Y > & val);
 
     // runtime quantity plus quantity 
     template<typename Unit1, typename Unit2, typename X, typename Y> 
       add_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::type 
-      operator+(const quantity< Unit1, X > & lhs, 
+      operator+(const quantity< Unit1, X > & lhs, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime quantity minus quantity 
     template<typename Unit1, typename Unit2, typename X, typename Y> 
       subtract_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::type 
-      operator-(const quantity< Unit1, X > & lhs, 
+      operator-(const quantity< Unit1, X > & lhs, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime quantity times quantity 
     template<typename Unit1, typename Unit2, typename X, typename Y> 
       multiply_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::type 
-      operator*(const quantity< Unit1, X > & lhs, 
+      operator*(const quantity< Unit1, X > & lhs, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime quantity divided by quantity 
     template<typename Unit1, typename Unit2, typename X, typename Y> 
       divide_typeof_helper< quantity< Unit1, X >, quantity< Unit2, Y > >::type 
-      operator/(const quantity< Unit1, X > & lhs, 
+      operator/(const quantity< Unit1, X > & lhs, 
                 const quantity< Unit2, Y > & rhs);
 
     // runtime operator== 
     template<typename Unit, typename X, typename Y> 
-      bool operator==(const quantity< Unit, X > & val1, 
+      bool operator==(const quantity< Unit, X > & val1, 
                       const quantity< Unit, Y > & val2);
 
     // runtime operator!= 
     template<typename Unit, typename X, typename Y> 
-      bool operator!=(const quantity< Unit, X > & val1, 
+      bool operator!=(const quantity< Unit, X > & val1, 
                       const quantity< Unit, Y > & val2);
 
     // runtime operator< 
     template<typename Unit, typename X, typename Y> 
-      bool operator<(const quantity< Unit, X > & val1, 
+      bool operator<(const quantity< Unit, X > & val1, 
                      const quantity< Unit, Y > & val2);
 
     // runtime operator<= 
     template<typename Unit, typename X, typename Y> 
-      bool operator<=(const quantity< Unit, X > & val1, 
+      bool operator<=(const quantity< Unit, X > & val1, 
                       const quantity< Unit, Y > & val2);
 
     // runtime operator> 
     template<typename Unit, typename X, typename Y> 
-      bool operator>(const quantity< Unit, X > & val1, 
+      bool operator>(const quantity< Unit, X > & val1, 
                      const quantity< Unit, Y > & val2);
 
     // runtime operator>= 
     template<typename Unit, typename X, typename Y> 
-      bool operator>=(const quantity< Unit, X > & val1, 
+      bool operator>=(const quantity< Unit, X > & val1, 
                       const quantity< Unit, Y > & val2);
   }
 }
    @@ -1092,17 +1094,23 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni

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

    namespace boost {
   namespace units {
-    template<typename S, typename Scale> struct scaled_base_unit;
     template<long Base, typename Exponent> struct scale;
     template<long Base, typename Exponent> 
-      std::string symbol_string(const scale< Base, Exponent > &);
+      std::string symbol_string(const scale< Base, Exponent > &);
     template<long Base, typename Exponent> 
-      std::string name_string(const scale< Base, Exponent > &);
+      std::string name_string(const scale< Base, Exponent > &);
+  }
+}
    + +
    +
    +
    namespace boost {
+  namespace units {
+    template<typename S, typename Scale> struct scaled_base_unit;
   }
 }
    -
    @@ -1125,7 +1133,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni // get decimal value of static_rational template<typename T, integer_type N, integer_type D> divide_typeof_helper< T, T >::type - value(const static_rational< N, D > &); + value(const static_rational< N, D > &); } }
    @@ -1134,53 +1142,53 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/unit.hpp> 
    namespace boost {
   namespace units {
-    template<typename Dim, typename System, typename Enable> class unit;
-
-    template<typename Dim, typename System> 
-      struct reduce_unit<unit< Dim, System >>;
     template<typename Dim, typename System, long N, long D> 
-      struct power_typeof_helper<unit< Dim, System >, static_rational< N, D >>;
+      struct power_typeof_helper<unit< Dim, System >, static_rational< N, D >>;
+    template<typename Dim, typename System> 
+      struct reduce_unit<unit< Dim, System >>;
     template<typename Dim, typename System, long N, long D> 
-      struct root_typeof_helper<unit< Dim, System >, static_rational< N, D >>;
+      struct root_typeof_helper<unit< Dim, System >, static_rational< N, D >>;
+
+    template<typename Dim, typename System, typename Enable> class unit;
 
     // unit runtime unary plus 
     template<typename Dim, typename System> 
       unary_plus_typeof_helper< unit< Dim, System > >::type 
-      operator+(const unit< Dim, System > &);
+      operator+(const unit< Dim, System > &);
 
     // unit runtime unary minus 
     template<typename Dim, typename System> 
       unary_minus_typeof_helper< unit< Dim, System > >::type 
-      operator-(const unit< Dim, System > &);
+      operator-(const unit< Dim, System > &);
 
     // runtime add two units 
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
       add_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::type 
-      operator+(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
+      operator+(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
 
     // runtime subtract two units 
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
       subtract_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::type 
-      operator-(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
+      operator-(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
 
     // runtime multiply two units 
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
       multiply_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::type 
-      operator*(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
+      operator*(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
 
     // runtime divide two units 
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
       divide_typeof_helper< unit< Dim1, System1 >, unit< Dim2, System2 > >::type 
-      operator/(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
+      operator/(const unit< Dim1, System1 > &, const unit< Dim2, System2 > &);
 
     // unit runtime operator==
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      bool operator==(const unit< Dim1, System1 > &, 
+      bool operator==(const unit< Dim1, System1 > &, 
                       const unit< Dim2, System2 > &);
 
     // unit runtime operator!=
     template<typename Dim1, typename Dim2, typename System1, typename System2> 
-      bool operator!=(const unit< Dim1, System1 > &, 
+      bool operator!=(const unit< Dim1, System1 > &, 
                       const unit< Dim2, System2 > &);
   }
 }
    @@ -1318,7 +1326,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/angular_acceleration.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< time_base_dimension,-2, plane_angle_base_dimension, 1 >::type angular_acceleration_dimension;  // derived dimension for angular acceleration : T^-2 QP 
+    typedef derived_dimension< time_base_dimension,-2, plane_angle_base_dimension, 1 >::type angular_acceleration_dimension;  // derived dimension for angular acceleration : T^-2 QP 
   }
 }
    @@ -1401,7 +1409,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/dynamic_viscosity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< mass_base_dimension, 1, length_base_dimension,-1, time_base_dimension,-1 >::type dynamic_viscosity_dimension;  // derived dimension for dynamic viscosity : M L^-1 T^-1 
+    typedef derived_dimension< mass_base_dimension, 1, length_base_dimension,-1, time_base_dimension,-1 >::type dynamic_viscosity_dimension;  // derived dimension for dynamic viscosity : M L^-1 T^-1 
   }
 }
    @@ -1419,7 +1427,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/electric_potential.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, time_base_dimension,-3, current_base_dimension,-1 >::type electric_potential_dimension;  // derived dimension for electric potential : L^2 M T^-3 I^-1 
+    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, time_base_dimension,-3, current_base_dimension,-1 >::type electric_potential_dimension;  // derived dimension for electric potential : L^2 M T^-3 I^-1 
   }
 }
    @@ -1473,7 +1481,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/illuminance.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension,-2, luminous_intensity_base_dimension, 1, solid_angle_base_dimension, 1 >::type illuminance_dimension;  // derived dimension for illuminance : L^-2 I QS 
+    typedef derived_dimension< length_base_dimension,-2, luminous_intensity_base_dimension, 1, solid_angle_base_dimension, 1 >::type illuminance_dimension;  // derived dimension for illuminance : L^-2 I QS 
   }
 }
    @@ -1511,7 +1519,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/kinematic_viscosity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 2, time_base_dimension,-1 >::type kinematic_viscosity_dimension;  // derived dimension for kinematic viscosity : L^2 T^-1 
+    typedef derived_dimension< length_base_dimension, 2, time_base_dimension,-1 >::type kinematic_viscosity_dimension;  // derived dimension for kinematic viscosity : L^2 T^-1 
   }
 }
    @@ -1531,7 +1539,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/luminance.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension,-2, luminous_intensity_base_dimension, 1 >::type luminance_dimension;  // derived dimension for luminance : L^-2 I 
+    typedef derived_dimension< length_base_dimension,-2, luminous_intensity_base_dimension, 1 >::type luminance_dimension;  // derived dimension for luminance : L^-2 I 
   }
 }
    @@ -1540,7 +1548,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/luminous_flux.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< luminous_intensity_base_dimension, 1, solid_angle_base_dimension, 1 >::type luminous_flux_dimension;  // derived dimension for luminous flux : I QS 
+    typedef derived_dimension< luminous_intensity_base_dimension, 1, solid_angle_base_dimension, 1 >::type luminous_flux_dimension;  // derived dimension for luminous flux : I QS 
   }
 }
    @@ -1549,9 +1557,9 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/luminous_intensity.hpp> 
    namespace boost {
   namespace units {
-    struct luminous_intensity_base_dimension;
+    struct luminous_intensity_base_dimension;
 
-    typedef luminous_intensity_base_dimension::dimension_type luminous_intensity_dimension;  // dimension of luminous intensity (J) 
+    typedef luminous_intensity_base_dimension::dimension_type luminous_intensity_dimension;  // dimension of luminous intensity (J) 
   }
 }
    @@ -1560,7 +1568,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/magnetic_field_intensity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension,-1, current_base_dimension, 1 >::type magnetic_field_intensity_dimension;  // derived dimension for magnetic field intensity : L^-1 I 
+    typedef derived_dimension< length_base_dimension,-1, current_base_dimension, 1 >::type magnetic_field_intensity_dimension;  // derived dimension for magnetic field intensity : L^-1 I 
   }
 }
    @@ -1578,7 +1586,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/magnetic_flux_density.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< mass_base_dimension, 1, time_base_dimension,-2, current_base_dimension,-1 >::type magnetic_flux_density_dimension;  // derived dimension for magnetic flux density : M T^-2 I^-1 
+    typedef derived_dimension< mass_base_dimension, 1, time_base_dimension,-2, current_base_dimension,-1 >::type magnetic_flux_density_dimension;  // derived dimension for magnetic flux density : M T^-2 I^-1 
   }
 }
    @@ -1616,7 +1624,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/molar_heat_capacity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, time_base_dimension,-2, temperature_base_dimension,-1, amount_base_dimension,-1 >::type molar_heat_capacity_dimension;  // derived dimension for molar heat capacity : L^2 M T^-2 Theta^-1 N^-1 
+    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, time_base_dimension,-2, temperature_base_dimension,-1, amount_base_dimension,-1 >::type molar_heat_capacity_dimension;  // derived dimension for molar heat capacity : L^2 M T^-2 Theta^-1 N^-1 
   }
 }
    @@ -1625,7 +1633,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/moment_of_inertia.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, plane_angle_base_dimension,-2 >::type moment_of_inertia_dimension;  // derived dimension for moment of inertia : L^2 M QP^-2 
+    typedef derived_dimension< length_base_dimension, 2, mass_base_dimension, 1, plane_angle_base_dimension,-2 >::type moment_of_inertia_dimension;  // derived dimension for moment of inertia : L^2 M QP^-2 
   }
 }
    @@ -1737,7 +1745,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/specific_heat_capacity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 2, time_base_dimension,-2, temperature_base_dimension,-1 >::type specific_heat_capacity_dimension;  // derived dimension for specific heat capacity : L^2 T^-2 Theta^-1 
+    typedef derived_dimension< length_base_dimension, 2, time_base_dimension,-2, temperature_base_dimension,-1 >::type specific_heat_capacity_dimension;  // derived dimension for specific heat capacity : L^2 T^-2 Theta^-1 
   }
 }
    @@ -1793,7 +1801,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/physical_dimensions/thermal_conductivity.hpp> 
    namespace boost {
   namespace units {
-    typedef derived_dimension< length_base_dimension, 1, mass_base_dimension, 1, time_base_dimension,-3, temperature_base_dimension,-1 >::type thermal_conductivity_dimension;  // derived dimension for thermal_conductivity : L^1 M^1 T^-3 Theta^-1 
+    typedef derived_dimension< length_base_dimension, 1, mass_base_dimension, 1, time_base_dimension,-3, temperature_base_dimension,-1 >::type thermal_conductivity_dimension;  // derived dimension for thermal_conductivity : L^1 M^1 T^-3 Theta^-1 
   }
 }
    @@ -2097,23 +2105,23 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha, quantity< mass >, 6.64465620e-27 *, 3.3e-34 *); // alpha-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha_over_m_e, quantity< dimensionless >, 7294.2995365 * dimensionless, 3.1e-6 * dimensionless); // alpha-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_alpha_over_m_p, quantity< dimensionless >, 3.97259968951 * dimensionless, 4.1e-10 * dimensionless); // alpha molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_alpha, + BOOST_UNITS_PHYSICAL_CONSTANT(M_alpha, quantity< mass_over_amount >, 4.001506179127e-3 *kilograms/ mole, 6.2e-14 *kilograms/ mole); @@ -2131,21 +2139,21 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(alpha, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(alpha, quantity< dimensionless >, 7.2973525376e-3 *, 5.0e-12 *); // Rydberg constant. - BOOST_UNITS_PHYSICAL_CONSTANT(R_infinity, quantity< wavenumber >, + BOOST_UNITS_PHYSICAL_CONSTANT(R_infinity, quantity< wavenumber >, 10973731.568527/ meter, 7.3e-5/ meter); // Bohr radius. - BOOST_UNITS_PHYSICAL_CONSTANT(a_0, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(a_0, quantity< length >, 0.52917720859e-10 * meters, 3.6e-20 * meters); // Hartree energy. - BOOST_UNITS_PHYSICAL_CONSTANT(E_h, quantity< energy >, + BOOST_UNITS_PHYSICAL_CONSTANT(E_h, quantity< energy >, 4.35974394e-18 * joules, 2.2e-25 * joules); } @@ -2163,68 +2171,68 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_d, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_d, quantity< mass >, 3.34358320e-27 *, 1.7e-34 *); // deuteron-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_d_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_d_over_m_e, quantity< dimensionless >, 3670.4829654 * dimensionless, 1.6e-6 * dimensionless); // deuteron-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_d_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_d_over_m_p, quantity< dimensionless >, 1.99900750108 * dimensionless, 2.2e-10 * dimensionless); // deuteron molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_d, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_d, quantity< mass_over_amount >, 2.013553212724e-3 *kilograms/ mole, 7.8e-14 *kilograms/ mole); // deuteron rms charge radius - BOOST_UNITS_PHYSICAL_CONSTANT(R_d, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(R_d, quantity< length >, 2.1402e-15 * meters, 2.8e-18 * meters); // deuteron magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d, quantity< energy_over_magnetic_flux_density >, 0.433073465e-26 *joules/ tesla, 1.1e-34 *joules/ tesla); // deuteron-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_B, quantity< dimensionless >, 0.4669754556e-3 * dimensionless, 3.9e-12 * dimensionless); // deuteron-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_N, quantity< dimensionless >, 0.8574382308 * dimensionless, 7.2e-9 * dimensionless); // deuteron g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_d, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_d, quantity< dimensionless >, 0.8574382308 * dimensionless, 7.2e-9 * dimensionless); // deuteron-electron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_e, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_e, quantity< dimensionless >, -4.664345537e-4 * dimensionless, 3.9e-12 * dimensionless); // deuteron-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_p, quantity< dimensionless >, 0.3070122070 * dimensionless, 2.4e-9 * dimensionless); // deuteron-neutron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_n, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_d_over_mu_n, quantity< dimensionless >, -0.44820652 * dimensionless, 1.1e-7 * dimensionless); @@ -2246,44 +2254,44 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace codata { // elementary charge - BOOST_UNITS_PHYSICAL_CONSTANT(e, quantity< electric_charge >, + BOOST_UNITS_PHYSICAL_CONSTANT(e, quantity< electric_charge >, 1.602176487e-19 * coulombs, 4.0e-27 * coulombs); // elementary charge to Planck constant ratio - BOOST_UNITS_PHYSICAL_CONSTANT(e_over_h, + BOOST_UNITS_PHYSICAL_CONSTANT(e_over_h, quantity< current_over_energy >, 2.417989454e14 *amperes/ joule, 6.0e6 *amperes/ joule); // magnetic flux quantum - BOOST_UNITS_PHYSICAL_CONSTANT(Phi_0, quantity< magnetic_flux >, + BOOST_UNITS_PHYSICAL_CONSTANT(Phi_0, quantity< magnetic_flux >, 2.067833667e-15 * webers, 5.2e-23 * webers); // conductance quantum - BOOST_UNITS_PHYSICAL_CONSTANT(G_0, quantity< conductance >, + BOOST_UNITS_PHYSICAL_CONSTANT(G_0, quantity< conductance >, 7.7480917004e-5 * siemens, 5.3e-14 * siemens); // Josephson constant. - BOOST_UNITS_PHYSICAL_CONSTANT(K_J, + BOOST_UNITS_PHYSICAL_CONSTANT(K_J, quantity< frequency_over_electric_potential >, 483597.891e9 *hertz/ volt, 1.2e7 *hertz/ volt); // von Klitzing constant - BOOST_UNITS_PHYSICAL_CONSTANT(R_K, quantity< resistance >, + BOOST_UNITS_PHYSICAL_CONSTANT(R_K, quantity< resistance >, 25812.807557 * ohms, 1.77e-5 * ohms); // Bohr magneton. - BOOST_UNITS_PHYSICAL_CONSTANT(mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_B, quantity< energy_over_magnetic_flux_density >, 927.400915e-26 *joules/ tesla, 2.3e-31 *joules/ tesla); // nuclear magneton - BOOST_UNITS_PHYSICAL_CONSTANT(mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_N, quantity< energy_over_magnetic_flux_density >, 5.05078324e-27 *joules/ tesla, 1.3e-34 *joules/ tesla); @@ -2302,137 +2310,137 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_e, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e, quantity< mass >, 9.10938215e-31 *, 4.5e-38 *); // electron-muon mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_mu, quantity< dimensionless >, 4.83633171e-3 * dimensionless, 1.2e-10 * dimensionless); // electron-tau mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_tau, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_tau, quantity< dimensionless >, 2.87564e-4 * dimensionless, 4.7e-8 * dimensionless); // electron-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_p, quantity< dimensionless >, 5.4461702177e-4 * dimensionless, 2.4e-13 * dimensionless); // electron-neutron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_n, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_n, quantity< dimensionless >, 5.4386734459e-4 * dimensionless, 3.3e-13 * dimensionless); // electron-deuteron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_d, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_d, quantity< dimensionless >, 2.7244371093e-4 * dimensionless, 1.2e-13 * dimensionless); // electron-alpha particle mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_alpha, + BOOST_UNITS_PHYSICAL_CONSTANT(m_e_over_m_alpha, quantity< dimensionless >, 1.37093355570e-4 * dimensionless, 5.8e-14 * dimensionless); // electron charge to mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(e_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(e_over_m_e, quantity< electric_charge_over_mass >, 1.758820150e11 *coulombs/ kilogram, 4.4e3 *coulombs/ kilogram); // electron molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_e, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_e, quantity< mass_over_amount >, 5.4857990943e-7 *kilograms/ mole, 2.3e-16 *kilograms/ mole); // Compton wavelength. - BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C, quantity< length >, 2.4263102175e-12 * meters, 3.3e-21 * meters); // classical electron radius - BOOST_UNITS_PHYSICAL_CONSTANT(r_e, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(r_e, quantity< length >, 2.8179402894e-15 * meters, 5.8e-24 * meters); // Thompson cross section. - BOOST_UNITS_PHYSICAL_CONSTANT(sigma_e, quantity< area >, + BOOST_UNITS_PHYSICAL_CONSTANT(sigma_e, quantity< area >, 0.6652458558e-28 * square_meters, 2.7e-37 * square_meters); // electron magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e, quantity< energy_over_magnetic_flux_density >, -928.476377e-26 *joules/ tesla, 2.3e-31 *joules/ tesla); // electron-Bohr magenton moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_B, quantity< dimensionless >, -1.00115965218111 * dimensionless, 7.4e-13 * dimensionless); // electron-nuclear magneton moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_N, quantity< dimensionless >, -183.28197092 * dimensionless, 8.0e-7 * dimensionless); // electron magnetic moment anomaly - BOOST_UNITS_PHYSICAL_CONSTANT(a_e, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(a_e, quantity< dimensionless >, 1.15965218111e-3 * dimensionless, 7.4e-13 * dimensionless); // electron g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_e, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_e, quantity< dimensionless >, -2.0023193043622 * dimensionless, 1.5e-12 * dimensionless); // electron-muon magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_mu, quantity< dimensionless >, 206.7669877 * dimensionless, 5.2e-6 * dimensionless); // electron-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_p, quantity< dimensionless >, -658.2106848 * dimensionless, 5.4e-6 * dimensionless); // electron-shielded proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_p_prime, quantity< dimensionless >, -658.2275971 * dimensionless, 7.2e-6 * dimensionless); // electron-neutron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_n, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_n, quantity< dimensionless >, 960.92050 * dimensionless, 2.3e-4 * dimensionless); // electron-deuteron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_d, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_d, quantity< dimensionless >, -2143.923498 * dimensionless, 1.8e-5 * dimensionless); // electron-shielded helion magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_h_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_e_over_mu_h_prime, quantity< dimensionless >, 864.058257 * dimensionless, 1.0e-5 * dimensionless); // electron gyromagnetic ratio - BOOST_UNITS_PHYSICAL_CONSTANT(gamma_e, + BOOST_UNITS_PHYSICAL_CONSTANT(gamma_e, quantity< frequency_over_magnetic_flux_density >, 1.760859770e11/second/ tesla, 4.4e3/second/ tesla); @@ -2451,58 +2459,58 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_h, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_h, quantity< mass >, 5.00641192e-27 *, 2.5e-34 *); // helion-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_h_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_h_over_m_e, quantity< dimensionless >, 5495.8852765 * dimensionless, 5.2e-6 * dimensionless); // helion-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_h_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_h_over_m_p, quantity< dimensionless >, 2.9931526713 * dimensionless, 2.6e-9 * dimensionless); // helion molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_h, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_h, quantity< mass_over_amount >, 3.0149322473e-3 *kilograms/ mole, 2.6e-12 *kilograms/ mole); // helion shielded magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime, quantity< energy_over_magnetic_flux_density >, -1.074552982e-26 *joules/ tesla, 3.0e-34 *joules/ tesla); // shielded helion-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_B, quantity< dimensionless >, -1.158671471e-3 * dimensionless, 1.4e-11 * dimensionless); // shielded helion-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_N, quantity< dimensionless >, -2.127497718 * dimensionless, 2.5e-8 * dimensionless); // shielded helion-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_p, quantity< dimensionless >, -0.761766558 * dimensionless, 1.1e-8 * dimensionless); // shielded helion-shielded proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_h_prime_over_mu_p_prime, quantity< dimensionless >, -0.7617861313 * dimensionless, 3.3e-8 * dimensionless); // shielded helion gyromagnetic ratio - BOOST_UNITS_PHYSICAL_CONSTANT(gamma_h_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(gamma_h_prime, quantity< frequency_over_magnetic_flux_density >, 2.037894730e8/second/ tesla, 5.6e-0/second/ tesla); @@ -2521,73 +2529,73 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_mu, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_mu, quantity< mass >, 1.88353130e-28 *, 1.1e-35 *); // muon-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_e, quantity< dimensionless >, 206.7682823 * dimensionless, 5.2e-6 * dimensionless); // muon-tau mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_tau, + BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_tau, quantity< dimensionless >, 5.94592e-2 * dimensionless, 9.7e-6 * dimensionless); // muon-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_p, quantity< dimensionless >, 0.1126095261 * dimensionless, 2.9e-9 * dimensionless); // muon-neutron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_n, + BOOST_UNITS_PHYSICAL_CONSTANT(m_mu_over_m_n, quantity< dimensionless >, 0.1124545167 * dimensionless, 2.9e-9 * dimensionless); // muon molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_mu, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_mu, quantity< mass_over_amount >, 0.1134289256e-3 *kilograms/ mole, 2.9e-12 *kilograms/ mole); // muon Compton wavelength - BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_mu, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_mu, quantity< length >, 11.73444104e-15 * meters, 3.0e-22 * meters); // muon magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu, quantity< energy_over_magnetic_flux_density >, -4.49044786e-26 *joules/ tesla, 1.6e-33 *joules/ tesla); // muon-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_B, quantity< dimensionless >, -4.84197049e-3 * dimensionless, 1.2e-10 * dimensionless); // muon-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_N, quantity< dimensionless >, -8.89059705 * dimensionless, 2.3e-7 * dimensionless); // muon magnetic moment anomaly - BOOST_UNITS_PHYSICAL_CONSTANT(a_mu, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(a_mu, quantity< dimensionless >, 1.16592069e-3 * dimensionless, 6.0e-10 * dimensionless); // muon g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_mu, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_mu, quantity< dimensionless >, -2.0023318414 * dimensionless, 1.2e-9 * dimensionless); // muon-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_mu_over_mu_p, quantity< dimensionless >, -3.183345137 * dimensionless, 8.5e-8 * dimensionless); @@ -2606,74 +2614,74 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_n, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_n, quantity< mass >, 1.674927211e-27 *, 8.4e-35 *); // neutron-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_e, quantity< dimensionless >, 1838.6836605 * dimensionless, 1.1e-6 * dimensionless); // neutron-muon mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_mu, quantity< dimensionless >, 8.89248409 * dimensionless, 2.3e-7 * dimensionless); // neutron-tau mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_tau, + BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_tau, quantity< dimensionless >, 0.528740 * dimensionless, 8.6e-5 * dimensionless); // neutron-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_n_over_m_p, quantity< dimensionless >, 1.00137841918 * dimensionless, 4.6e-10 * dimensionless); // neutron molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_n, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_n, quantity< mass_over_amount >, 1.00866491597e-3 *kilograms/ mole, 4.3e-13 *kilograms/ mole); // neutron Compton wavelength - BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_n, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_n, quantity< length >, 1.3195908951e-15 * meters, 2.0e-24 * meters); // neutron magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_n, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_n, quantity< energy_over_magnetic_flux_density >, -0.96623641e-26 *joules/ tesla, 2.3e-33 *joules/ tesla); // neutron g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_n, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_n, quantity< dimensionless >, -3.82608545 * dimensionless, 9.0e-7 * dimensionless); // neutron-electron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_e, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_e, quantity< dimensionless >, 1.04066882e-3 * dimensionless, 2.5e-10 * dimensionless); // neutron-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_p, quantity< dimensionless >, -0.68497934 * dimensionless, 1.6e-7 * dimensionless); // neutron-shielded proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_n_over_mu_p_prime, quantity< dimensionless >, -0.68499694 * dimensionless, 1.6e-7 * dimensionless); // neutron gyromagnetic ratio - BOOST_UNITS_PHYSICAL_CONSTANT(gamma_n, + BOOST_UNITS_PHYSICAL_CONSTANT(gamma_n, quantity< frequency_over_magnetic_flux_density >, 1.83247185e8/second/ tesla, 4.3e1/second/ tesla); @@ -2694,61 +2702,61 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace codata { // Avogadro constant. - BOOST_UNITS_PHYSICAL_CONSTANT(N_A, quantity< inverse_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(N_A, quantity< inverse_amount >, 6.02214179e23/ mole, 3.0e16/ mole); // atomic mass constant - BOOST_UNITS_PHYSICAL_CONSTANT(m_u, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_u, quantity< mass >, 1.660538782e-27 * kilograms, 8.3e-35 * kilograms); // Faraday constant. - BOOST_UNITS_PHYSICAL_CONSTANT(F, + BOOST_UNITS_PHYSICAL_CONSTANT(F, quantity< electric_charge_over_amount >, 96485.3399 *coulombs/ mole, 2.4e-3 *coulombs/ mole); // molar gas constant - BOOST_UNITS_PHYSICAL_CONSTANT(R, + BOOST_UNITS_PHYSICAL_CONSTANT(R, quantity< energy_over_temperature_amount >, 8.314472 *joules/kelvin/ mole, 1.5e-5 *joules/kelvin/ mole); // Boltzmann constant. - BOOST_UNITS_PHYSICAL_CONSTANT(k_B, + BOOST_UNITS_PHYSICAL_CONSTANT(k_B, quantity< energy_over_temperature >, 1.3806504e-23 *joules/ kelvin, 2.4e-29 *joules/ kelvin); // Stefan-Boltzmann constant. - BOOST_UNITS_PHYSICAL_CONSTANT(sigma_SB, + BOOST_UNITS_PHYSICAL_CONSTANT(sigma_SB, quantity< power_over_area_temperature_4 >, 5.670400e-8 *watts/square_meter/pow< 4 >, 4.0e-13 *watts/square_meter/pow< 4 >); // first radiation constant - BOOST_UNITS_PHYSICAL_CONSTANT(c_1, quantity< power_area >, + BOOST_UNITS_PHYSICAL_CONSTANT(c_1, quantity< power_area >, 3.74177118e-16 *watt * square_meters, 1.9e-23 *watt * square_meters); // first radiation constant for spectral radiance - BOOST_UNITS_PHYSICAL_CONSTANT(c_1L, + BOOST_UNITS_PHYSICAL_CONSTANT(c_1L, quantity< power_area_over_solid_angle >, 1.191042759e-16 *watt *square_meters/ steradian, 5.9e-24 *watt *square_meters/ steradian); // second radiation constant - BOOST_UNITS_PHYSICAL_CONSTANT(c_2, quantity< length_temperature >, + BOOST_UNITS_PHYSICAL_CONSTANT(c_2, quantity< length_temperature >, 1.4387752e-2 *meter * kelvin, 2.5e-8 *meter * kelvin); // Wien displacement law constant : lambda_max T. - BOOST_UNITS_PHYSICAL_CONSTANT(b, quantity< length_temperature >, + BOOST_UNITS_PHYSICAL_CONSTANT(b, quantity< length_temperature >, 2.8977685e-3 *meter * kelvin, 5.1e-9 *meter * kelvin); // Wien displacement law constant : nu_max/T. - BOOST_UNITS_PHYSICAL_CONSTANT(b_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(b_prime, quantity< frequency_over_temperature >, 5.878933e10 *hertz/ kelvin, 1.0e15 *hertz/ kelvin); @@ -2767,115 +2775,115 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_p, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_p, quantity< mass >, 1.672621637e-27 *, 8.3e-35 *); // proton-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_e, quantity< dimensionless >, 1836.15267247 * dimensionless, 8.0e-7 * dimensionless); // proton-muon mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_mu, quantity< dimensionless >, 8.88024339 * dimensionless, 2.3e-7 * dimensionless); // proton-tau mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_tau, + BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_tau, quantity< dimensionless >, 0.528012 * dimensionless, 8.6e-5 * dimensionless); // proton-neutron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_n, + BOOST_UNITS_PHYSICAL_CONSTANT(m_p_over_m_n, quantity< dimensionless >, 0.99862347824 * dimensionless, 4.6e-10 * dimensionless); // proton charge to mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(e_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(e_over_m_p, quantity< electric_charge_over_mass >, 9.57883392e7 *coulombs/ kilogram, 2.4e0 *coulombs/ kilogram); // proton molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_p, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_p, quantity< mass_over_amount >, 1.00727646677e-3 *kilograms/ mole, 1.0e-13 *kilograms/ mole); // proton Compton wavelength - BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_p, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_p, quantity< length >, 1.3214098446e-15 * meters, 1.9e-24 * meters); // proton rms charge radius - BOOST_UNITS_PHYSICAL_CONSTANT(R_p, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(R_p, quantity< length >, 0.8768e-15 * meters, 6.9e-18 * meters); // proton magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p, quantity< energy_over_magnetic_flux_density >, 1.410606662e-26 *joules/ tesla, 3.7e-34 *joules/ tesla); // proton-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_B, quantity< dimensionless >, 1.521032209e-3 * dimensionless, 1.2e-11 * dimensionless); // proton-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_N, quantity< dimensionless >, 2.792847356 * dimensionless, 2.3e-8 * dimensionless); // proton g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_p, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_p, quantity< dimensionless >, 5.585694713 * dimensionless, 4.6e-8 * dimensionless); // proton-neutron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_n, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_over_mu_n, quantity< dimensionless >, -1.45989806 * dimensionless, 3.4e-7 * dimensionless); // shielded proton magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime, quantity< energy_over_magnetic_flux_density >, 1.410570419e-26 *joules/ tesla, 3.8e-34 *joules/ tesla); // shielded proton-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime_over_mu_B, quantity< dimensionless >, 1.520993128e-3 * dimensionless, 1.7e-11 * dimensionless); // shielded proton-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_p_prime_over_mu_N, quantity< dimensionless >, 2.792775598 * dimensionless, 3.0e-8 * dimensionless); // proton magnetic shielding correction - BOOST_UNITS_PHYSICAL_CONSTANT(sigma_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(sigma_p_prime, quantity< dimensionless >, 25.694e-6 * dimensionless, 1.4e-8 * dimensionless); // proton gyromagnetic ratio - BOOST_UNITS_PHYSICAL_CONSTANT(gamma_p, + BOOST_UNITS_PHYSICAL_CONSTANT(gamma_p, quantity< frequency_over_magnetic_flux_density >, 2.675222099e8/second/ tesla, 7.0e0/second/ tesla); // shielded proton gyromagnetic ratio - BOOST_UNITS_PHYSICAL_CONSTANT(gamma_p_prime, + BOOST_UNITS_PHYSICAL_CONSTANT(gamma_p_prime, quantity< frequency_over_magnetic_flux_density >, 2.675153362e8/second/ tesla, 7.3e0/second/ tesla); @@ -2894,40 +2902,40 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_tau, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_tau, quantity< mass >, 3.16777e-27 *, 5.2e-31 *); // tau-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_e, quantity< dimensionless >, 3477.48 * dimensionless, 5.7e-1 * dimensionless); // tau-muon mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_mu, + BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_mu, quantity< dimensionless >, 16.8183 * dimensionless, 2.7e-3 * dimensionless); // tau-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_p, quantity< dimensionless >, 1.89390 * dimensionless, 3.1e-4 * dimensionless); // tau-neutron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_n, + BOOST_UNITS_PHYSICAL_CONSTANT(m_tau_over_m_n, quantity< dimensionless >, 1.89129 * dimensionless, 3.1e-4 * dimensionless); // tau molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_tau, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_tau, quantity< mass_over_amount >, 1.90768e-3 *kilograms/ mole, 3.1e-7 *kilograms/ mole); // tau Compton wavelength - BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_tau, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(lambda_C_tau, quantity< length >, 0.69772e-15 * meters, 1.1e-19 * meters); } @@ -2945,63 +2953,63 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(m_t, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_t, quantity< mass >, 5.00735588e-27 *, 2.5e-34 *); // triton-electron mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_t_over_m_e, + BOOST_UNITS_PHYSICAL_CONSTANT(m_t_over_m_e, quantity< dimensionless >, 5496.9215269 * dimensionless, 5.1e-6 * dimensionless); // triton-proton mass ratio - BOOST_UNITS_PHYSICAL_CONSTANT(m_t_over_m_p, + BOOST_UNITS_PHYSICAL_CONSTANT(m_t_over_m_p, quantity< dimensionless >, 2.9937170309 * dimensionless, 2.5e-9 * dimensionless); // triton molar mass - BOOST_UNITS_PHYSICAL_CONSTANT(M_t, quantity< mass_over_amount >, + BOOST_UNITS_PHYSICAL_CONSTANT(M_t, quantity< mass_over_amount >, 3.0155007134e-3 *kilograms/ mole, 2.5e-12 *kilograms/ mole); // triton magnetic moment - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t, quantity< energy_over_magnetic_flux_density >, 1.504609361e-26 *joules/ tesla, 4.2e-34 *joules/ tesla); // triton-Bohr magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_B, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_B, quantity< dimensionless >, 1.622393657e-3 * dimensionless, 2.1e-11 * dimensionless); // triton-nuclear magneton ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_N, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_N, quantity< dimensionless >, 2.978962448 * dimensionless, 3.8e-8 * dimensionless); // triton g-factor - BOOST_UNITS_PHYSICAL_CONSTANT(g_t, quantity< dimensionless >, + BOOST_UNITS_PHYSICAL_CONSTANT(g_t, quantity< dimensionless >, 5.957924896 * dimensionless, 7.6e-8 * dimensionless); // triton-electron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_e, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_e, quantity< dimensionless >, -1.620514423e-3 * dimensionless, 2.1e-11 * dimensionless); // triton-proton magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_p, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_p, quantity< dimensionless >, 1.066639908 * dimensionless, 1.0e-8 * dimensionless); // triton-neutron magnetic moment ratio - BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_n, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_t_over_mu_n, quantity< dimensionless >, -1.55718553 * dimensionless, 3.7e-7 * dimensionless); @@ -3019,25 +3027,25 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - typedef divide_typeof_helper< frequency, electric_potential >::type frequency_over_electric_potential; + typedef divide_typeof_helper< frequency, electric_potential >::type frequency_over_electric_potential; typedef divide_typeof_helper< electric_charge, mass >::type electric_charge_over_mass; typedef divide_typeof_helper< mass, amount >::type mass_over_amount; - typedef divide_typeof_helper< energy, magnetic_flux_density >::type energy_over_magnetic_flux_density; - typedef divide_typeof_helper< frequency, magnetic_flux_density >::type frequency_over_magnetic_flux_density; + typedef divide_typeof_helper< energy, magnetic_flux_density >::type energy_over_magnetic_flux_density; + typedef divide_typeof_helper< frequency, magnetic_flux_density >::type frequency_over_magnetic_flux_density; typedef divide_typeof_helper< current, energy >::type current_over_energy; typedef divide_typeof_helper< dimensionless, amount >::type inverse_amount; typedef divide_typeof_helper< energy, temperature >::type energy_over_temperature; - typedef divide_typeof_helper< energy_over_temperature, amount >::type energy_over_temperature_amount; - typedef divide_typeof_helper< divide_typeof_helper< power, area >::type, power_typeof_helper< temperature, static_rational< 4 > >::type >::type power_over_area_temperature_4; + typedef divide_typeof_helper< energy_over_temperature, amount >::type energy_over_temperature_amount; + typedef divide_typeof_helper< divide_typeof_helper< power, area >::type, power_typeof_helper< temperature, static_rational< 4 > >::type >::type power_over_area_temperature_4; typedef multiply_typeof_helper< power, area >::type power_area; - typedef divide_typeof_helper< power_area, solid_angle >::type power_area_over_solid_angle; + typedef divide_typeof_helper< power_area, solid_angle >::type power_area_over_solid_angle; typedef multiply_typeof_helper< length, temperature >::type length_temperature; typedef divide_typeof_helper< frequency, temperature >::type frequency_over_temperature; typedef divide_typeof_helper< divide_typeof_helper< force, current >::type, current >::type force_over_current_squared; typedef divide_typeof_helper< capacitance, length >::type capacitance_over_length; - typedef divide_typeof_helper< divide_typeof_helper< divide_typeof_helper< volume, mass >::type, time >::type, time >::type volume_over_mass_time_squared; + typedef divide_typeof_helper< divide_typeof_helper< divide_typeof_helper< volume, mass >::type, time >::type, time >::type volume_over_mass_time_squared; typedef multiply_typeof_helper< energy, time >::type energy_time; - typedef divide_typeof_helper< electric_charge, amount >::type electric_charge_over_amount; + typedef divide_typeof_helper< electric_charge, amount >::type electric_charge_over_amount; } } } @@ -3053,59 +3061,59 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni namespace si { namespace constants { namespace codata { - BOOST_UNITS_PHYSICAL_CONSTANT(c, quantity< velocity >, + BOOST_UNITS_PHYSICAL_CONSTANT(c, quantity< velocity >, 299792458.0 *meters/, 0.0 *meters/); // magnetic constant (exactly 4 pi x 10^(-7) - error is due to finite precision of pi) - BOOST_UNITS_PHYSICAL_CONSTANT(mu_0, + BOOST_UNITS_PHYSICAL_CONSTANT(mu_0, quantity< force_over_current_squared >, 12.56637061435917295385057353311801153679e-7 *newtons/ampere/ ampere, 0.0 *newtons/ampere/ ampere); // electric constant - BOOST_UNITS_PHYSICAL_CONSTANT(epsilon_0, + BOOST_UNITS_PHYSICAL_CONSTANT(epsilon_0, quantity< capacitance_over_length >, 8.854187817620389850536563031710750260608e-12 *farad/ meter, 0.0 *farad/ meter); // characteristic impedance of vacuum - BOOST_UNITS_PHYSICAL_CONSTANT(Z_0, quantity< resistance >, + BOOST_UNITS_PHYSICAL_CONSTANT(Z_0, quantity< resistance >, 376.7303134617706554681984004203193082686 * ohm, 0.0 * ohm); // Newtonian constant of gravitation. - BOOST_UNITS_PHYSICAL_CONSTANT(G, + BOOST_UNITS_PHYSICAL_CONSTANT(G, quantity< volume_over_mass_time_squared >, 6.67428e-11 *cubic_meters/kilogram/second/ second, 6.7e-15 *cubic_meters/kilogram/second/ second); // Planck constant. - BOOST_UNITS_PHYSICAL_CONSTANT(h, quantity< energy_time >, + BOOST_UNITS_PHYSICAL_CONSTANT(h, quantity< energy_time >, 6.62606896e-34 *joule * seconds, 3.3e-41 *joule * seconds); // Dirac constant. - BOOST_UNITS_PHYSICAL_CONSTANT(hbar, quantity< energy_time >, + BOOST_UNITS_PHYSICAL_CONSTANT(hbar, quantity< energy_time >, 1.054571628e-34 *joule * seconds, 5.3e-42 *joule * seconds); // Planck mass. - BOOST_UNITS_PHYSICAL_CONSTANT(m_P, quantity< mass >, + BOOST_UNITS_PHYSICAL_CONSTANT(m_P, quantity< mass >, 2.17644e-8 * kilograms, 1.1e-12 * kilograms); // Planck temperature. - BOOST_UNITS_PHYSICAL_CONSTANT(T_P, quantity< temperature >, + BOOST_UNITS_PHYSICAL_CONSTANT(T_P, quantity< temperature >, 1.416785e32 * kelvin, 7.1e27 * kelvin); // Planck length. - BOOST_UNITS_PHYSICAL_CONSTANT(l_P, quantity< length >, + BOOST_UNITS_PHYSICAL_CONSTANT(l_P, quantity< length >, 1.616252e-35 * meters, 8.1e-40 * meters); // Planck time. - BOOST_UNITS_PHYSICAL_CONSTANT(t_P, quantity< time >, + BOOST_UNITS_PHYSICAL_CONSTANT(t_P, quantity< time >, 5.39124e-44 * seconds, 2.7e-48 * seconds); } @@ -3294,40 +3302,40 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/systems/si/io.hpp> 
    namespace boost {
   namespace units {
-    std::string name_string(const reduce_unit< si::absorbed_dose >::type &);
-    std::string symbol_string(const reduce_unit< si::absorbed_dose >::type &);
-    std::string name_string(const reduce_unit< si::capacitance >::type &);
-    std::string symbol_string(const reduce_unit< si::capacitance >::type &);
-    std::string name_string(const reduce_unit< si::catalytic_activity >::type &);
-    std::string symbol_string(const reduce_unit< si::catalytic_activity >::type &);
-    std::string name_string(const reduce_unit< si::conductance >::type &);
-    std::string symbol_string(const reduce_unit< si::conductance >::type &);
-    std::string name_string(const reduce_unit< si::electric_charge >::type &);
-    std::string symbol_string(const reduce_unit< si::electric_charge >::type &);
-    std::string name_string(const reduce_unit< si::electric_potential >::type &);
-    std::string symbol_string(const reduce_unit< si::electric_potential >::type &);
-    std::string name_string(const reduce_unit< si::energy >::type &);
-    std::string symbol_string(const reduce_unit< si::energy >::type &);
-    std::string name_string(const reduce_unit< si::force >::type &);
-    std::string symbol_string(const reduce_unit< si::force >::type &);
-    std::string name_string(const reduce_unit< si::frequency >::type &);
-    std::string symbol_string(const reduce_unit< si::frequency >::type &);
-    std::string name_string(const reduce_unit< si::illuminance >::type &);
-    std::string symbol_string(const reduce_unit< si::illuminance >::type &);
-    std::string name_string(const reduce_unit< si::inductance >::type &);
-    std::string symbol_string(const reduce_unit< si::inductance >::type &);
-    std::string name_string(const reduce_unit< si::luminous_flux >::type &);
-    std::string symbol_string(const reduce_unit< si::luminous_flux >::type &);
-    std::string name_string(const reduce_unit< si::magnetic_flux >::type &);
-    std::string symbol_string(const reduce_unit< si::magnetic_flux >::type &);
-    std::string name_string(const reduce_unit< si::magnetic_flux_density >::type &);
-    std::string symbol_string(const reduce_unit< si::magnetic_flux_density >::type &);
-    std::string name_string(const reduce_unit< si::power >::type &);
-    std::string symbol_string(const reduce_unit< si::power >::type &);
-    std::string name_string(const reduce_unit< si::pressure >::type &);
-    std::string symbol_string(const reduce_unit< si::pressure >::type &);
-    std::string name_string(const reduce_unit< si::resistance >::type &);
-    std::string symbol_string(const reduce_unit< si::resistance >::type &);
+    std::string name_string(const reduce_unit< si::absorbed_dose >::type &);
+    std::string symbol_string(const reduce_unit< si::absorbed_dose >::type &);
+    std::string name_string(const reduce_unit< si::capacitance >::type &);
+    std::string symbol_string(const reduce_unit< si::capacitance >::type &);
+    std::string name_string(const reduce_unit< si::catalytic_activity >::type &);
+    std::string symbol_string(const reduce_unit< si::catalytic_activity >::type &);
+    std::string name_string(const reduce_unit< si::conductance >::type &);
+    std::string symbol_string(const reduce_unit< si::conductance >::type &);
+    std::string name_string(const reduce_unit< si::electric_charge >::type &);
+    std::string symbol_string(const reduce_unit< si::electric_charge >::type &);
+    std::string name_string(const reduce_unit< si::electric_potential >::type &);
+    std::string symbol_string(const reduce_unit< si::electric_potential >::type &);
+    std::string name_string(const reduce_unit< si::energy >::type &);
+    std::string symbol_string(const reduce_unit< si::energy >::type &);
+    std::string name_string(const reduce_unit< si::force >::type &);
+    std::string symbol_string(const reduce_unit< si::force >::type &);
+    std::string name_string(const reduce_unit< si::frequency >::type &);
+    std::string symbol_string(const reduce_unit< si::frequency >::type &);
+    std::string name_string(const reduce_unit< si::illuminance >::type &);
+    std::string symbol_string(const reduce_unit< si::illuminance >::type &);
+    std::string name_string(const reduce_unit< si::inductance >::type &);
+    std::string symbol_string(const reduce_unit< si::inductance >::type &);
+    std::string name_string(const reduce_unit< si::luminous_flux >::type &);
+    std::string symbol_string(const reduce_unit< si::luminous_flux >::type &);
+    std::string name_string(const reduce_unit< si::magnetic_flux >::type &);
+    std::string symbol_string(const reduce_unit< si::magnetic_flux >::type &);
+    std::string name_string(const reduce_unit< si::magnetic_flux_density >::type &);
+    std::string symbol_string(const reduce_unit< si::magnetic_flux_density >::type &);
+    std::string name_string(const reduce_unit< si::power >::type &);
+    std::string symbol_string(const reduce_unit< si::power >::type &);
+    std::string name_string(const reduce_unit< si::pressure >::type &);
+    std::string symbol_string(const reduce_unit< si::pressure >::type &);
+    std::string name_string(const reduce_unit< si::resistance >::type &);
+    std::string symbol_string(const reduce_unit< si::resistance >::type &);
   }
 }
    @@ -3452,7 +3460,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni static const mass_density kilogram_per_cubic_meter; static const mass_density kilograms_per_cubic_meter; static const mass_density kilogramme_per_cubic_metre; - static const mass_density kilogrammes_per_cubic_metre; + static const mass_density kilogrammes_per_cubic_metre; } } } @@ -3534,30 +3542,30 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/systems/si/prefixes.hpp> 
     
-BOOST_UNITS_METRIC_PREFIX(exponent, name)
    +BOOST_UNITS_METRIC_PREFIX(exponent, name) 
    namespace boost {
   namespace units {
     namespace si {
-       BOOST_UNITS_METRIC_PREFIX(- 24, yocto);
-       BOOST_UNITS_METRIC_PREFIX(- 21, zepto);
-       BOOST_UNITS_METRIC_PREFIX(- 18, atto);
-       BOOST_UNITS_METRIC_PREFIX(- 15, femto);
-       BOOST_UNITS_METRIC_PREFIX(- 12, pico);
-       BOOST_UNITS_METRIC_PREFIX(- 9, nano);
-       BOOST_UNITS_METRIC_PREFIX(- 6, micro);
-       BOOST_UNITS_METRIC_PREFIX(- 3, milli);
-       BOOST_UNITS_METRIC_PREFIX(- 2, centi);
-       BOOST_UNITS_METRIC_PREFIX(- 1, deci);
-       BOOST_UNITS_METRIC_PREFIX(1, deka);
-       BOOST_UNITS_METRIC_PREFIX(2, hecto);
-       BOOST_UNITS_METRIC_PREFIX(3, kilo);
-       BOOST_UNITS_METRIC_PREFIX(6, mega);
-       BOOST_UNITS_METRIC_PREFIX(9, giga);
-       BOOST_UNITS_METRIC_PREFIX(12, tera);
-       BOOST_UNITS_METRIC_PREFIX(15, peta);
-       BOOST_UNITS_METRIC_PREFIX(18, exa);
-       BOOST_UNITS_METRIC_PREFIX(21, zetta);
-       BOOST_UNITS_METRIC_PREFIX(24, yotta);
+       BOOST_UNITS_METRIC_PREFIX(- 24, yocto);
+       BOOST_UNITS_METRIC_PREFIX(- 21, zepto);
+       BOOST_UNITS_METRIC_PREFIX(- 18, atto);
+       BOOST_UNITS_METRIC_PREFIX(- 15, femto);
+       BOOST_UNITS_METRIC_PREFIX(- 12, pico);
+       BOOST_UNITS_METRIC_PREFIX(- 9, nano);
+       BOOST_UNITS_METRIC_PREFIX(- 6, micro);
+       BOOST_UNITS_METRIC_PREFIX(- 3, milli);
+       BOOST_UNITS_METRIC_PREFIX(- 2, centi);
+       BOOST_UNITS_METRIC_PREFIX(- 1, deci);
+       BOOST_UNITS_METRIC_PREFIX(1, deka);
+       BOOST_UNITS_METRIC_PREFIX(2, hecto);
+       BOOST_UNITS_METRIC_PREFIX(3, kilo);
+       BOOST_UNITS_METRIC_PREFIX(6, mega);
+       BOOST_UNITS_METRIC_PREFIX(9, giga);
+       BOOST_UNITS_METRIC_PREFIX(12, tera);
+       BOOST_UNITS_METRIC_PREFIX(15, peta);
+       BOOST_UNITS_METRIC_PREFIX(18, exa);
+       BOOST_UNITS_METRIC_PREFIX(21, zetta);
+       BOOST_UNITS_METRIC_PREFIX(24, yotta);
     }
   }
 }
    @@ -3636,8 +3644,8 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni static const surface_density kilogram_per_square_meter; static const surface_density kilograms_per_square_meter; - static const surface_density kilogramme_per_square_metre; - static const surface_density kilogrammes_per_square_metre; + static const surface_density kilogramme_per_square_metre; + static const surface_density kilogrammes_per_square_metre; } } } @@ -3894,22 +3902,22 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/systems/cgs/io.hpp> 
    namespace boost {
   namespace units {
-    std::string name_string(const reduce_unit< cgs::acceleration >::type &);
-    std::string symbol_string(const reduce_unit< cgs::acceleration >::type &);
-    std::string name_string(const reduce_unit< cgs::current >::type &);
-    std::string symbol_string(const reduce_unit< cgs::current >::type &);
-    std::string name_string(const reduce_unit< cgs::dynamic_viscosity >::type &);
-    std::string symbol_string(const reduce_unit< cgs::dynamic_viscosity >::type &);
-    std::string name_string(const reduce_unit< cgs::energy >::type &);
-    std::string symbol_string(const reduce_unit< cgs::energy >::type &);
-    std::string name_string(const reduce_unit< cgs::force >::type &);
-    std::string symbol_string(const reduce_unit< cgs::force >::type &);
-    std::string name_string(const reduce_unit< cgs::kinematic_viscosity >::type &);
-    std::string symbol_string(const reduce_unit< cgs::kinematic_viscosity >::type &);
-    std::string name_string(const reduce_unit< cgs::pressure >::type &);
-    std::string symbol_string(const reduce_unit< cgs::pressure >::type &);
-    std::string name_string(const reduce_unit< cgs::wavenumber >::type &);
-    std::string symbol_string(const reduce_unit< cgs::wavenumber >::type &);
+    std::string name_string(const reduce_unit< cgs::acceleration >::type &);
+    std::string symbol_string(const reduce_unit< cgs::acceleration >::type &);
+    std::string name_string(const reduce_unit< cgs::current >::type &);
+    std::string symbol_string(const reduce_unit< cgs::current >::type &);
+    std::string name_string(const reduce_unit< cgs::dynamic_viscosity >::type &);
+    std::string symbol_string(const reduce_unit< cgs::dynamic_viscosity >::type &);
+    std::string name_string(const reduce_unit< cgs::energy >::type &);
+    std::string symbol_string(const reduce_unit< cgs::energy >::type &);
+    std::string name_string(const reduce_unit< cgs::force >::type &);
+    std::string symbol_string(const reduce_unit< cgs::force >::type &);
+    std::string name_string(const reduce_unit< cgs::kinematic_viscosity >::type &);
+    std::string symbol_string(const reduce_unit< cgs::kinematic_viscosity >::type &);
+    std::string name_string(const reduce_unit< cgs::pressure >::type &);
+    std::string symbol_string(const reduce_unit< cgs::pressure >::type &);
+    std::string name_string(const reduce_unit< cgs::wavenumber >::type &);
+    std::string symbol_string(const reduce_unit< cgs::wavenumber >::type &);
   }
 }
    @@ -4168,6 +4176,106 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni

    +Information System Reference

    +
    +
    Header <boost/units/systems/information/bit.hpp>
    +
    Header <boost/units/systems/information/byte.hpp>
    +
    Header <boost/units/systems/information/hartley.hpp>
    +
    Header <boost/units/systems/information/nat.hpp>
    +
    Header <boost/units/systems/information/shannon.hpp>
    +
    +
    +
    +
    namespace boost {
+  namespace units {
+    namespace information {
+      static const hu::bit::info bit;
+      static const hu::bit::info bits;
+      namespace hu {
+        namespace bit {
+          typedef unit< information_dimension, make_system< bit_base_unit >::type > info;
+        }
+      }
+    }
+  }
+}
    +
    +
    +
    +
    namespace boost {
+  namespace units {
+    namespace information {
+      typedef make_system< byte_base_unit >::type system;
+      typedef unit< dimensionless_type, system > dimensionless;
+      typedef hu::byte::info info;
+
+      static const hu::byte::info byte;
+      static const hu::byte::info bytes;
+      namespace hu {
+        namespace byte {
+          typedef unit< information_dimension, system > info;
+        }
+      }
+    }
+  }
+}
    +
    +
    +
    +
    namespace boost {
+  namespace units {
+    namespace information {
+      static const hu::hartley::info hartley;
+      static const hu::hartley::info hartleys;
+      namespace hu {
+        namespace hartley {
+          typedef unit< information_dimension, make_system< hartley_base_unit >::type > info;
+        }
+      }
+    }
+  }
+}
    +
    +
    +
    +
    namespace boost {
+  namespace units {
+    namespace information {
+      static const hu::nat::info nat;
+      static const hu::nat::info nats;
+      namespace hu {
+        namespace nat {
+          typedef unit< information_dimension, make_system< nat_base_unit >::type > info;
+        }
+      }
+    }
+  }
+}
    +
    +
    +
    +
    namespace boost {
+  namespace units {
+    namespace information {
+      static const hu::shannon::info shannon;
+      static const hu::shannon::info shannons;
+      namespace hu {
+        namespace shannon {
+          typedef unit< information_dimension, make_system< shannon_base_unit >::type > info;
+        }
+      }
+    }
+  }
+}
    +
    +
    +
    +

    Abstract System Reference

    Header <boost/units/systems/abstract.hpp>
    @@ -4175,27 +4283,27 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni Header <boost/units/systems/abstract.hpp>
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<abstract::length_unit_tag>;
-    template<> struct base_unit_info<abstract::mass_unit_tag>;
-    template<> struct base_unit_info<abstract::time_unit_tag>;
-    template<> struct base_unit_info<abstract::current_unit_tag>;
-    template<> struct base_unit_info<abstract::temperature_unit_tag>;
-    template<> struct base_unit_info<abstract::amount_unit_tag>;
-    template<> struct base_unit_info<abstract::luminous_intensity_unit_tag>;
-    template<> struct base_unit_info<abstract::plane_angle_unit_tag>;
-    template<> struct base_unit_info<abstract::solid_angle_unit_tag>;
+    template<> struct base_unit_info<abstract::amount_unit_tag>;
+    template<> struct base_unit_info<abstract::current_unit_tag>;
+    template<> struct base_unit_info<abstract::length_unit_tag>;
+    template<> struct base_unit_info<abstract::luminous_intensity_unit_tag>;
+    template<> struct base_unit_info<abstract::mass_unit_tag>;
+    template<> struct base_unit_info<abstract::plane_angle_unit_tag>;
+    template<> struct base_unit_info<abstract::solid_angle_unit_tag>;
+    template<> struct base_unit_info<abstract::temperature_unit_tag>;
+    template<> struct base_unit_info<abstract::time_unit_tag>;
     namespace abstract {
+      struct amount_unit_tag;
+      struct current_unit_tag;
       struct length_unit_tag;
+      struct luminous_intensity_unit_tag;
       struct mass_unit_tag;
-      struct time_unit_tag;
-      struct current_unit_tag;
-      struct temperature_unit_tag;
-      struct amount_unit_tag;
-      struct luminous_intensity_unit_tag;
       struct plane_angle_unit_tag;
       struct solid_angle_unit_tag;
+      struct temperature_unit_tag;
+      struct time_unit_tag;
 
-      typedef make_system< 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 >::type system;
+      typedef make_system< 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 >::type system;
       typedef unit< length_dimension, system > length;  // abstract unit of length 
       typedef unit< mass_dimension, system > mass;  // abstract unit of mass 
       typedef unit< time_dimension, system > time;  // abstract unit of time 
@@ -4242,7 +4350,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/angle/arcminute.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<angle::arcminute_base_unit>;
+    template<> struct base_unit_info<angle::arcminute_base_unit>;
     namespace angle {
       typedef scaled_base_unit< degree_base_unit, scale< 60, static_rational<-1 > > > arcminute_base_unit;
     }
@@ -4254,7 +4362,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/angle/arcsecond.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<angle::arcsecond_base_unit>;
+    template<> struct base_unit_info<angle::arcsecond_base_unit>;
     namespace angle {
       typedef scaled_base_unit< degree_base_unit, scale< 3600, static_rational<-1 > > > arcsecond_base_unit;
     }
@@ -4299,7 +4407,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/angle/revolution.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<angle::revolution_base_unit>;
+    template<> struct base_unit_info<angle::revolution_base_unit>;
     namespace angle {
       typedef scaled_base_unit< degree_base_unit, scale< 360, static_rational< 1 > > > revolution_base_unit;
     }
@@ -4336,7 +4444,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 
    namespace boost {
   namespace units {
     namespace astronomical {
-      struct astronomical_unit_base_unit;
+      struct astronomical_unit_base_unit;
     }
   }
 }
    
@@ -4346,7 +4454,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/astronomical/light_day.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<astronomical::light_day_base_unit>;
+    template<> struct base_unit_info<astronomical::light_day_base_unit>;
     namespace astronomical {
       typedef scaled_base_unit< boost::units::astronomical::light_second_base_unit, scale< 86400, static_rational< 1 > > > light_day_base_unit;
     }
@@ -4358,7 +4466,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/astronomical/light_hour.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<astronomical::light_hour_base_unit>;
+    template<> struct base_unit_info<astronomical::light_hour_base_unit>;
     namespace astronomical {
       typedef scaled_base_unit< boost::units::astronomical::light_second_base_unit, scale< 3600, static_rational< 1 > > > light_hour_base_unit;
     }
@@ -4370,7 +4478,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/astronomical/light_minute.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<astronomical::light_minute_base_unit>;
+    template<> struct base_unit_info<astronomical::light_minute_base_unit>;
     namespace astronomical {
       typedef scaled_base_unit< boost::units::astronomical::light_second_base_unit, scale< 60, static_rational< 1 > > > light_minute_base_unit;
     }
@@ -4393,7 +4501,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/astronomical/light_year.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<astronomical::light_year_base_unit>;
+    template<> struct base_unit_info<astronomical::light_year_base_unit>;
     namespace astronomical {
       typedef scaled_base_unit< boost::units::astronomical::light_second_base_unit, scale< 31557600, static_rational< 1 > > > light_year_base_unit;
     }
@@ -4484,7 +4592,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/drachm.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::drachm_base_unit>;
+    template<> struct base_unit_info<imperial::drachm_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 16, static_rational<-2 > > > drachm_base_unit;
     }
@@ -4496,7 +4604,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/fluid_ounce.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::fluid_ounce_base_unit>;
+    template<> struct base_unit_info<imperial::fluid_ounce_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pint_base_unit, scale< 20, static_rational<-1 > > > fluid_ounce_base_unit;
     }
@@ -4508,7 +4616,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/foot.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::foot_base_unit>;
+    template<> struct base_unit_info<imperial::foot_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 3, static_rational<-1 > > > foot_base_unit;
     }
@@ -4520,7 +4628,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/furlong.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::furlong_base_unit>;
+    template<> struct base_unit_info<imperial::furlong_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 220, static_rational< 1 > > > furlong_base_unit;
     }
@@ -4532,7 +4640,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/gallon.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::gallon_base_unit>;
+    template<> struct base_unit_info<imperial::gallon_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pint_base_unit, scale< 8, static_rational< 1 > > > gallon_base_unit;
     }
@@ -4544,7 +4652,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/gill.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::gill_base_unit>;
+    template<> struct base_unit_info<imperial::gill_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pint_base_unit, scale< 4, static_rational<-1 > > > gill_base_unit;
     }
@@ -4556,7 +4664,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/grain.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::grain_base_unit>;
+    template<> struct base_unit_info<imperial::grain_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 7000, static_rational<-1 > > > grain_base_unit;
     }
@@ -4568,7 +4676,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/hundredweight.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::hundredweight_base_unit>;
+    template<> struct base_unit_info<imperial::hundredweight_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 112, static_rational< 1 > > > hundredweight_base_unit;
     }
@@ -4580,7 +4688,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/inch.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::inch_base_unit>;
+    template<> struct base_unit_info<imperial::inch_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 36, static_rational<-1 > > > inch_base_unit;
     }
@@ -4592,7 +4700,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/league.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::league_base_unit>;
+    template<> struct base_unit_info<imperial::league_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 5280, static_rational< 1 > > > league_base_unit;
     }
@@ -4604,7 +4712,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/mile.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::mile_base_unit>;
+    template<> struct base_unit_info<imperial::mile_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 1760, static_rational< 1 > > > mile_base_unit;
     }
@@ -4616,7 +4724,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/ounce.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::ounce_base_unit>;
+    template<> struct base_unit_info<imperial::ounce_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 2, static_rational<-4 > > > ounce_base_unit;
     }
@@ -4650,7 +4758,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/quart.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::quart_base_unit>;
+    template<> struct base_unit_info<imperial::quart_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational< 1 > > > quart_base_unit;
     }
@@ -4662,7 +4770,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/quarter.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::quarter_base_unit>;
+    template<> struct base_unit_info<imperial::quarter_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 28, static_rational< 1 > > > quarter_base_unit;
     }
@@ -4674,7 +4782,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/stone.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::stone_base_unit>;
+    template<> struct base_unit_info<imperial::stone_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 14, static_rational< 1 > > > stone_base_unit;
     }
@@ -4686,7 +4794,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/thou.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::thou_base_unit>;
+    template<> struct base_unit_info<imperial::thou_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< yard_base_unit, scale< 36000, static_rational<-1 > > > thou_base_unit;
     }
@@ -4698,7 +4806,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/imperial/ton.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<imperial::ton_base_unit>;
+    template<> struct base_unit_info<imperial::ton_base_unit>;
     namespace imperial {
       typedef scaled_base_unit< pound_base_unit, scale< 2240, static_rational< 1 > > > ton_base_unit;
     }
@@ -4745,7 +4853,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/angstrom.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::angstrom_base_unit>;
+    template<> struct base_unit_info<metric::angstrom_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::meter_base_unit, scale< 10, static_rational<-10 > > > angstrom_base_unit;
     }
@@ -4801,7 +4909,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/day.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::day_base_unit>;
+    template<> struct base_unit_info<metric::day_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::second_base_unit, scale< 86400, static_rational< 1 > > > day_base_unit;
     }
@@ -4813,7 +4921,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/fermi.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::fermi_base_unit>;
+    template<> struct base_unit_info<metric::fermi_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::meter_base_unit, scale< 10, static_rational<-15 > > > fermi_base_unit;
     }
@@ -4836,7 +4944,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/hour.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::hour_base_unit>;
+    template<> struct base_unit_info<metric::hour_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::second_base_unit, scale< 60, static_rational< 2 > > > hour_base_unit;
     }
@@ -4870,7 +4978,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/micron.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::micron_base_unit>;
+    template<> struct base_unit_info<metric::micron_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::meter_base_unit, scale< 10, static_rational<-6 > > > micron_base_unit;
     }
@@ -4882,7 +4990,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/minute.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::minute_base_unit>;
+    template<> struct base_unit_info<metric::minute_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::second_base_unit, scale< 60, static_rational< 1 > > > minute_base_unit;
     }
@@ -4905,7 +5013,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/nautical_mile.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::nautical_mile_base_unit>;
+    template<> struct base_unit_info<metric::nautical_mile_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::meter_base_unit, scale< 1852, static_rational< 1 > > > nautical_mile_base_unit;
     }
@@ -4917,7 +5025,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/ton.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::ton_base_unit>;
+    template<> struct base_unit_info<metric::ton_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::kilogram_base_unit, scale< 1000, static_rational< 1 > > > ton_base_unit;
     }
@@ -4940,7 +5048,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/metric/year.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<metric::year_base_unit>;
+    template<> struct base_unit_info<metric::year_base_unit>;
     namespace metric {
       typedef scaled_base_unit< boost::units::si::second_base_unit, scale< 31557600, static_rational< 1 > > > year_base_unit;
     }
@@ -5100,7 +5208,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/cup.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::cup_base_unit>;
+    template<> struct base_unit_info<us::cup_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational<-1 > > > cup_base_unit;
     }
@@ -5112,7 +5220,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/dram.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::dram_base_unit>;
+    template<> struct base_unit_info<us::dram_base_unit>;
     namespace us {
       typedef scaled_base_unit< pound_base_unit, scale< 16, static_rational<-2 > > > dram_base_unit;
     }
@@ -5124,7 +5232,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/fluid_dram.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::fluid_dram_base_unit>;
+    template<> struct base_unit_info<us::fluid_dram_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational<-7 > > > fluid_dram_base_unit;
     }
@@ -5136,7 +5244,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/fluid_ounce.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::fluid_ounce_base_unit>;
+    template<> struct base_unit_info<us::fluid_ounce_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 16, static_rational<-1 > > > fluid_ounce_base_unit;
     }
@@ -5148,7 +5256,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/foot.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::foot_base_unit>;
+    template<> struct base_unit_info<us::foot_base_unit>;
     namespace us {
       typedef scaled_base_unit< yard_base_unit, scale< 3, static_rational<-1 > > > foot_base_unit;
     }
@@ -5160,7 +5268,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/gallon.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::gallon_base_unit>;
+    template<> struct base_unit_info<us::gallon_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational< 3 > > > gallon_base_unit;
     }
@@ -5172,7 +5280,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/gill.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::gill_base_unit>;
+    template<> struct base_unit_info<us::gill_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational<-2 > > > gill_base_unit;
     }
@@ -5184,7 +5292,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/grain.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::grain_base_unit>;
+    template<> struct base_unit_info<us::grain_base_unit>;
     namespace us {
       typedef scaled_base_unit< pound_base_unit, scale< 7000, static_rational<-1 > > > grain_base_unit;
     }
@@ -5196,7 +5304,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/hundredweight.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::hundredweight_base_unit>;
+    template<> struct base_unit_info<us::hundredweight_base_unit>;
     namespace us {
       typedef scaled_base_unit< pound_base_unit, scale< 100, static_rational< 1 > > > hundredweight_base_unit;
     }
@@ -5208,7 +5316,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/inch.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::inch_base_unit>;
+    template<> struct base_unit_info<us::inch_base_unit>;
     namespace us {
       typedef scaled_base_unit< yard_base_unit, scale< 36, static_rational<-1 > > > inch_base_unit;
     }
@@ -5220,7 +5328,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/mil.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::mil_base_unit>;
+    template<> struct base_unit_info<us::mil_base_unit>;
     namespace us {
       typedef scaled_base_unit< yard_base_unit, scale< 36000, static_rational<-1 > > > mil_base_unit;
     }
@@ -5232,7 +5340,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/mile.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::mile_base_unit>;
+    template<> struct base_unit_info<us::mile_base_unit>;
     namespace us {
       typedef scaled_base_unit< yard_base_unit, scale< 1760, static_rational< 1 > > > mile_base_unit;
     }
@@ -5244,7 +5352,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/minim.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::minim_base_unit>;
+    template<> struct base_unit_info<us::minim_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 7680, static_rational<-1 > > > minim_base_unit;
     }
@@ -5256,7 +5364,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/ounce.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::ounce_base_unit>;
+    template<> struct base_unit_info<us::ounce_base_unit>;
     namespace us {
       typedef scaled_base_unit< pound_base_unit, scale< 2, static_rational<-4 > > > ounce_base_unit;
     }
@@ -5301,7 +5409,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/quart.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::quart_base_unit>;
+    template<> struct base_unit_info<us::quart_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational< 1 > > > quart_base_unit;
     }
@@ -5313,7 +5421,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/tablespoon.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::tablespoon_base_unit>;
+    template<> struct base_unit_info<us::tablespoon_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 2, static_rational<-5 > > > tablespoon_base_unit;
     }
@@ -5325,7 +5433,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/teaspoon.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::teaspoon_base_unit>;
+    template<> struct base_unit_info<us::teaspoon_base_unit>;
     namespace us {
       typedef scaled_base_unit< pint_base_unit, scale< 96, static_rational<-1 > > > teaspoon_base_unit;
     }
@@ -5337,7 +5445,7 @@ Boost.Lambda's return type deduction system is extented to make use of Boost.Uni
 Header <boost/units/base_units/us/ton.hpp>
 
    namespace boost {
   namespace units {
-    template<> struct base_unit_info<us::ton_base_unit>;
+    template<> struct base_unit_info<us::ton_base_unit>;
     namespace us {
       typedef scaled_base_unit< pound_base_unit, scale< 2000, static_rational< 1 > > > ton_base_unit;
     }
diff --git a/doc/html/boost_units/Units.html b/doc/html/boost_units/Units.html
index 1940e26c7b..de85e07c19 100644
--- a/doc/html/boost_units/Units.html
+++ b/doc/html/boost_units/Units.html
@@ -84,7 +84,7 @@
       dimension associated with powers and roots must be computed at compile-time,
       it is not possible to provide overloads for std::pow that
       function correctly for units.
-      These operations are supported through free functions pow and root that are templated
+      These operations are supported through free functions pow and root that are templated
       on integer and static_rational
       values and can take as an argument any type for which the utility classes
       power_typeof_helper
diff --git a/doc/html/boost_units/version_id.html b/doc/html/boost_units/version_id.html
index 1aae943535..d80dfa2d4b 100644
--- a/doc/html/boost_units/version_id.html
+++ b/doc/html/boost_units/version_id.html
@@ -30,7 +30,7 @@
       Boost root
     
    
 
    
-      Last edit to Quickbook file units.qbk was at 10:20:57 AM on 2014-Oct-30.
+      Last edit to Quickbook file units.qbk was at 11:51:27 PM on 2015-Apr-07.
     
    
 
    
-- 
cgit v1.2.3