[Boost-commit] svn:boost r4339

From: steven_watanabe_at_[hidden]
Date: 2007-05-28 18:55:05

Author: steven_watanabe
Date: 2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
New Revision: 4339
URL: http://svn.boost.org/trac/boost/changeset/4339

Log:
changed absolute

Text files modified: 
   sandbox/units/boost/units/absolute.hpp                       |    56 ++++++++++++++++++                      
   sandbox/units/boost/units/conversion.hpp                     |    61 +++++++++++++++++++-                    
   sandbox/units/boost/units/quantity.hpp                       |   118 +++++++-------------------------------- 
   sandbox/units/boost/units/systems/base_units.hpp             |    27 ++++++--                                
   sandbox/units/boost/units/systems/temperature/celsius.hpp    |    16 +----                                   
   sandbox/units/boost/units/systems/temperature/fahrenheit.hpp |    14 +---                                    
   sandbox/units/libs/units/example/unit_example_20.cpp         |   100 ++++++++++++++++++---------------       
   7 files changed, 218 insertions(+), 174 deletions(-)

Modified: sandbox/units/boost/units/absolute.hpp
==============================================================================
--- sandbox/units/boost/units/absolute.hpp	(original)
+++ sandbox/units/boost/units/absolute.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -13,6 +13,8 @@
 
 #include <iosfwd>
 
+#include <boost/units/conversion.hpp>
+
 namespace boost {
 
 namespace units {
@@ -39,6 +41,41 @@
         value_type   val_;
 };
 
+template<class From, class To>
+struct affine_conversion_helper {
+    //F = 9/5 C + 32
+    //5/9 F = C + 32 * 5/9
+    //C = 5/9 F - 32 * 5/9
+    typedef typename affine_conversion_helper<To, From>::type type;
+    static type value() { return(-affine_conversion_helper<To, From>::value() * conversion_factor<type>(From(), To())); }
+};
+
+template<class Unit1, class T1, class Unit2, class T2>
+struct conversion_helper<quantity<absolute<Unit1>, T1>, quantity<absolute<Unit2>, T2> > {
+    typedef quantity<absolute<Unit1>, T1> from_quantity_type;
+    typedef quantity<absolute<Unit2>, T2> to_quantity_type;
+    static to_quantity_type convert(const from_quantity_type& source) {
+        return(
+            to_quantity_type::from_value(
+                source.value() *
+                conversion_factor(Unit1(), Unit2()) +
+                affine_conversion_helper<typename reduce_unit<Unit1>::type, typename reduce_unit<Unit2>::type>::value()));
+    }
+};
+
+// a macro for consistancy
+#define BOOST_UNITS_DEFINE_AFFINE_CONVERSION(From, To, type_, value_)\
+    namespace boost {\
+    namespace units {\
+    template<>\
+    struct affine_conversion_helper<From, To> {\
+        typedef type_ type;\
+        static type value() {return(value_);}\
+    };\
+    }\
+    }\
+    void boost_units_require_semicolon()
+
 template<class Y>
 absolute<Y> operator+(const absolute<Y>& aval,const Y& rval)
 {
@@ -63,6 +100,25 @@
     return Y(aval1.value()-aval2.value());
 }
 
+template<class U, class T>
+class quantity;
+
+template<class D, class S>
+class unit;
+
+template<class Unit>
+struct reduce_unit;
+
+template<class D, class S>
+struct reduce_unit<absolute<unit<D, S> > > {
+    typedef absolute<typename reduce_unit<unit<D, S> >::type> type;
+};
+
+template<class D, class S, class T>
+quantity<absolute<unit<D, S> >, T> operator*(const T& t, const absolute<unit<D, S> >&) {
+    return(quantity<absolute<unit<D, S> >, T>::from_value(t));
+}
+
 template<class Y>
 std::ostream& operator<<(std::ostream& os,const absolute<Y>& aval)
 {

Modified: sandbox/units/boost/units/conversion.hpp
==============================================================================
--- sandbox/units/boost/units/conversion.hpp	(original)
+++ sandbox/units/boost/units/conversion.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -216,13 +216,68 @@
     }
 };
 
-template<class Y,class FromUnit,class ToUnit>
+namespace detail {
+
+template<class Source, class Dest>
+struct conversion_factor_helper;
+
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, homogeneous_system<L2> > > {
+    typedef typename reduce_unit<unit<D, homogeneous_system<L1> > >::type source_unit;
+    typedef typename source_unit::system_type::type unit_list;
+    typedef typename detail::conversion_impl<mpl::size<unit_list>::value>::template apply<
+        typename mpl::begin<unit_list>::type,
+        homogeneous_system<L2>
+    > impl;
+    typedef typename impl::type type;
+    static type value() {
+        return(impl::value());
+    }
+};
+
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, heterogeneous_system<L1> >, unit<D, homogeneous_system<L2> > > {
+    typedef typename detail::conversion_impl<mpl::size<typename L1::type>::value>::template apply<
+        typename mpl::begin<typename L1::type>::type,
+        homogeneous_system<L2>
+    > impl;
+    typedef typename impl::type type;
+    static type convert() {
+        return(impl::value());
+    }
+};
+
+// There is no simple algorithm for doing this conversion
+// other than just defining it as the reverse of the
+// heterogeneous->homogeneous case
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, heterogeneous_system<L2> > > {
+    typedef typename detail::conversion_impl<mpl::size<typename L2::type>::value>::template apply<
+        typename mpl::begin<typename L2::type>::type,
+        homogeneous_system<L1>
+    > impl;
+    typedef typename impl::type type;
+    static type value() {
+        return(one() / impl::value());
+    }
+};
+
+}
+
+template<class FromUnit,class ToUnit>
+inline
+typename detail::conversion_factor_helper<FromUnit, ToUnit>::type
+conversion_factor(const FromUnit&,const ToUnit&)
+{
+    return(detail::conversion_factor_helper<FromUnit, ToUnit>::value());
+}
+
+template<class Y, class FromUnit,class ToUnit>
 inline
 Y
 conversion_factor(const FromUnit&,const ToUnit&)
 {
-    // dangerous if conversion is not regular...don't know how to deal with this yet
-    return quantity<ToUnit,Y>(Y(1)*FromUnit()).value();
+    return(static_cast<Y>(detail::conversion_factor_helper<FromUnit, ToUnit>::value()));
 }
 
 } //namespace units

Modified: sandbox/units/boost/units/quantity.hpp
==============================================================================
--- sandbox/units/boost/units/quantity.hpp	(original)
+++ sandbox/units/boost/units/quantity.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -67,16 +67,13 @@
 template<class Unit,class Y = double>
 class quantity
 {
+        enum { force_instantiation_of_unit = sizeof(Unit) };
     public:
         typedef quantity<Unit,Y>                        this_type;
         
         typedef Y                                       value_type;
-        typedef typename get_system<Unit>::type         system_type;
-        typedef typename get_dimension<Unit>::type      dimension_type;
-        typedef unit<dimension_type,system_type>        unit_type;
-
-        BOOST_STATIC_ASSERT((detail::check_system<system_type,dimension_type>::value == true));
-         
+        typedef Unit        unit_type;
+ 
         quantity() : val_() 
         { 
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -100,7 +97,7 @@
 
         /// implicit conversion between value types is allowed if allowed for value types themselves
         template<class YY>
-        quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
+        quantity(const quantity<Unit,YY>& source,
             typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
             val_(source.value())
         { 
@@ -109,7 +106,7 @@
 
         /// implicit conversion between value types is not allowed if not allowed for value types themselves
         template<class YY>
-        explicit quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
+        explicit quantity(const quantity<Unit,YY>& source,
             typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
             val_(static_cast<Y>(source.value()))
         { 
@@ -120,7 +117,7 @@
 
         /// implicit conversion between value types is allowed if allowed for value types themselves
         template<class YY>
-        quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
+        quantity(const quantity<Unit,YY>& source) :
             val_(source.value())
         { 
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -131,7 +128,7 @@
         
         /// implicit assignment between value types is allowed if allowed for value types themselves
         template<class YY>
-        this_type& operator=(const quantity<unit<dimension_type,system_type>,YY>& source)
+        this_type& operator=(const quantity<Unit,YY>& source)
         {
             BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
 
@@ -143,31 +140,33 @@
         #ifndef BOOST_NO_SFINAE
 
         /// explicit conversion between different unit systems is allowed if implicit conversion is disallowed
-        template<class System2,class Dim2,class YY> 
+        template<class Unit2,class YY> 
         explicit
-        quantity(const quantity<unit<Dim2,System2>,YY>& source, 
+        quantity(const quantity<Unit2,YY>& source, 
                  typename boost::disable_if<
                     mpl::and_<
-                        is_implicitly_convertible<unit<Dim2,System2>,unit_type>,
+                        //is_implicitly_convertible should be undefined when the
+                        //units are not convertible at all
+                        typename is_implicitly_convertible<Unit2,Unit>::type,
                         detail::is_non_narrowing_conversion<YY, Y>
                     >
                  >::type* = 0)
-             : val_(conversion_helper<quantity<unit<Dim2,System2>,YY>,this_type>::convert(source).value())
+             : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
         }
 
         /// implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible
-        template<class System2,class Dim2,class YY> 
-        quantity(const quantity<unit<Dim2,System2>,YY>& source, 
+        template<class Unit2,class YY> 
+        quantity(const quantity<Unit2,YY>& source, 
                  typename boost::enable_if<
                      mpl::and_<
-                         is_implicitly_convertible<unit<Dim2,System2>,unit_type>,
+                         typename is_implicitly_convertible<Unit2,Unit>::type,
                          detail::is_non_narrowing_conversion<YY, Y>
                      >
                  >::type* = 0)
-             : val_(conversion_helper<quantity<unit<Dim2,System2>,YY>,this_type>::convert(source).value())
+             : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
@@ -177,9 +176,9 @@
 
         /// without SFINAE we can't distinguish between explicit and implicit conversions so 
         /// the conversion is always explicit
-        template<class System2,class Dim2,class YY> 
-        explicit quantity(const quantity<unit<Dim2,System2>,YY>& source)
-             : val_(conversion_helper<quantity<unit<Dim2,System2>,YY>,this_type>::convert(source).value())
+        template<class Unit2,class YY> 
+        explicit quantity(const quantity<Unit2,YY>& source)
+             : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
@@ -188,13 +187,11 @@
         #endif
         
         /// implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible 
-        template<class System2,class Dim2,class YY>
-        this_type& operator=(const quantity<unit<Dim2,System2>,YY>& source)
+        template<class Unit2,class YY>
+        this_type& operator=(const quantity<Unit2,YY>& source)
         {
-            typedef unit_type                       unit1_type;
-            typedef unit<Dim2,System2>              unit2_type;
             
-            BOOST_STATIC_ASSERT((is_implicitly_convertible<unit2_type,unit1_type>::value == true));
+            BOOST_STATIC_ASSERT((is_implicitly_convertible<Unit2,unit_type>::value == true));
             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
             
             *this = this_type(source);
@@ -454,75 +451,6 @@
     using std::swap;
     swap(quantity_cast<Y&>(lhs),quantity_cast<Y&>(rhs));
 }
-//
-///// utility class to simplify construction of dimensionless quantities
-//template<class System,class Y>
-//struct dimensionless_quantity
-//{
-//    typedef quantity<typename dimensionless_unit<System>::type,Y>   type;
-//};
-//
-///// check that a type is a quantity
-//template<typename T>
-//struct is_quantity :
-//    public mpl::false_
-//{ };
-//
-//template<class Unit,
-//         class Y>
-//struct is_quantity< quantity<Unit,Y> > : 
-//    public mpl::true_
-//{ };
-//
-///// check that a type is a quantity of the specified dimension
-//template<class T,class Dim>
-//struct is_quantity_of_dimension :
-//    public mpl::false_
-//{ };
-//
-//template<class Dim,class System,class Y>
-//struct is_quantity_of_dimension< quantity< unit<Dim,System>,Y>,Dim > :
-//    public mpl::true_
-//{ };
-//
-///// check that a type is a dimensionless quantity
-//template<class T>
-//struct is_dimensionless_quantity :
-//    public is_quantity_of_dimension<T,dimensionless_type>
-//{ };
-//
-///// check that a type is a quantity in a specified system
-//template<class T,class System>
-//struct is_quantity_of_system :
-//    public mpl::false_
-//{ };
-//
-//template<class Dim,
-//         class System,
-//         class Y>
-//struct is_quantity_of_system< quantity< unit<Dim,System>,Y>,System > :
-//    public mpl::true_
-//{ };
-//
-///// check that a type is dimensionless
-//template<class System,class Y>
-//struct is_dimensionless< quantity<unit<dimensionless_type,System>,Y> > :
-//    public mpl::true_
-//{ };
-//
-///// get dimension
-//template<class Unit,class Y>
-//struct get_dimension< quantity<Unit,Y> >
-//{
-//    typedef typename get_dimension<Unit>::type  type;
-//};
-//
-///// get system
-//template<class Unit,class Y>
-//struct get_system< quantity<Unit,Y> >
-//{
-//    typedef typename get_system<Unit>::type     type;
-//};
 
 /// specialize unary plus typeof helper
 template<class Unit,class Y>

Modified: sandbox/units/boost/units/systems/base_units.hpp
==============================================================================
--- sandbox/units/boost/units/systems/base_units.hpp	(original)
+++ sandbox/units/boost/units/systems/base_units.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -16,6 +16,7 @@
 #include <boost/units/config.hpp>
 #include <boost/units/base_unit.hpp>
 #include <boost/units/scaled_base_unit.hpp>
+#include <boost/units/absolute.hpp>
 #include <boost/units/systems/physical_units.hpp>
 
 namespace boost {
@@ -76,35 +77,39 @@
     static std::string name() { return("kelvin"); }
     static std::string symbol() { return("K"); }
 };
-struct fahrenheit_tag : public base_unit<fahrenheit_tag, temperature_type, -8> {
+struct celsius_tag : public base_unit<celsius_tag, temperature_type, -8> {
+    static std::string name() { return("celsius"); }
+    static std::string symbol() { return("C"); }
+};
+struct fahrenheit_tag : public base_unit<fahrenheit_tag, temperature_type, -7> {
     static std::string name() { return("fahrenheit"); }
     static std::string symbol() { return("F"); }
 };
 
-struct mole_tag : public base_unit<mole_tag, amount_type, -7> {
+struct mole_tag : public base_unit<mole_tag, amount_type, -6> {
     static std::string name() { return("mole"); }
     static std::string symbol() { return("mol"); }
 };
 
-struct candela_tag : public base_unit<candela_tag, luminous_intensity_type, -6> {
+struct candela_tag : public base_unit<candela_tag, luminous_intensity_type, -5> {
     static std::string name() { return("candela"); }
     static std::string symbol() { return("cd"); }
 };
 
-struct radian_tag : public base_unit<radian_tag, plane_angle_type, -5> {
+struct radian_tag : public base_unit<radian_tag, plane_angle_type, -4> {
     static std::string name() { return("radian"); }
     static std::string symbol() { return("rad"); }
 };
-struct degree_tag : public base_unit<degree_tag, plane_angle_type, -4> {
+struct degree_tag : public base_unit<degree_tag, plane_angle_type, -3> {
     static std::string name() { return("degree"); }
     static std::string symbol() { return("deg"); }
 };
-struct gradian_tag : public base_unit<gradian_tag, plane_angle_type, -3> {
+struct gradian_tag : public base_unit<gradian_tag, plane_angle_type, -2> {
     static std::string name() { return("gradian"); }
     static std::string symbol() { return("grad"); }
 };
 
-struct steradian_tag : public base_unit<steradian_tag, solid_angle_type, -2> {
+struct steradian_tag : public base_unit<steradian_tag, solid_angle_type, -1> {
     static std::string name() { return("steradian"); }
     static std::string symbol() { return("sr"); }
 };
@@ -113,6 +118,14 @@
 
 }
 
+BOOST_UNITS_DEFINE_CONVERSION(boost::units::kelvin_tag, boost::units::celsius_tag::unit_type, one, one());
+BOOST_UNITS_DEFINE_CONVERSION(boost::units::kelvin_tag, boost::units::fahrenheit_tag::unit_type, double, 9.0/5.0);
+BOOST_UNITS_DEFINE_CONVERSION(boost::units::celsius_tag, boost::units::fahrenheit_tag::unit_type, double, 9.0/5.0);
+
+BOOST_UNITS_DEFINE_AFFINE_CONVERSION(boost::units::kelvin_tag::unit_type, boost::units::celsius_tag::unit_type, double, 273.15);
+BOOST_UNITS_DEFINE_AFFINE_CONVERSION(boost::units::kelvin_tag::unit_type, boost::units::fahrenheit_tag::unit_type, double, 273.15 * 9.0 / 5.0 + 32.0);
+BOOST_UNITS_DEFINE_AFFINE_CONVERSION(boost::units::celsius_tag::unit_type, boost::units::fahrenheit_tag::unit_type, double, 32.0);
+
 BOOST_UNITS_DEFINE_CONVERSION(boost::units::radian_tag, boost::units::degree_tag::unit_type, double, 180/3.14159265358979323846);
 BOOST_UNITS_DEFINE_CONVERSION(boost::units::radian_tag, boost::units::gradian_tag::unit_type, double, 200/3.14159265358979323846);
 BOOST_UNITS_DEFINE_CONVERSION(boost::units::degree_tag, boost::units::gradian_tag::unit_type, double, 10/9.);

Modified: sandbox/units/boost/units/systems/temperature/celsius.hpp
==============================================================================
--- sandbox/units/boost/units/systems/temperature/celsius.hpp	(original)
+++ sandbox/units/boost/units/systems/temperature/celsius.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -14,10 +14,10 @@
 #include <string>
 
 #include <boost/units/absolute.hpp>
-#include <boost/units/io.hpp>
 #include <boost/units/static_constant.hpp>
-#include <boost/units/system.hpp>
+#include <boost/units/make_system.hpp>
 #include <boost/units/systems/physical_units.hpp>
+#include <boost/units/systems/base_units.hpp>
 
 namespace boost {
 
@@ -25,9 +25,7 @@
 
 namespace celsius {
 
-struct system_tag : public ordinal<111> { };
-
-typedef homogeneous_system<system_tag>  system;
+typedef make_system<celsius_tag>::type system;
 
 typedef unit<temperature_type,system>   temperature;
 
@@ -35,15 +33,9 @@
 BOOST_UNITS_STATIC_CONSTANT(degrees,temperature);
 
 } // namespace celsius
-
-template<> struct base_unit_info<temperature_dim,celsius::system_tag>
-{
-    static std::string name()               { return "Celsius"; }
-    static std::string symbol()             { return "C"; }
-};
         
 } // namespace units
 
 } // namespace boost
 
-#endif // BOOST_UNITS_CELSIUS_HPP
\ No newline at end of file
+#endif // BOOST_UNITS_CELSIUS_HPP

Modified: sandbox/units/boost/units/systems/temperature/fahrenheit.hpp
==============================================================================
--- sandbox/units/boost/units/systems/temperature/fahrenheit.hpp	(original)
+++ sandbox/units/boost/units/systems/temperature/fahrenheit.hpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -16,8 +16,8 @@
 #include <boost/units/absolute.hpp>
 #include <boost/units/io.hpp>
 #include <boost/units/static_constant.hpp>
-#include <boost/units/system.hpp>
 #include <boost/units/systems/physical_units.hpp>
+#include <boost/units/systems/base_unit.hpp>
 
 namespace boost {
 
@@ -25,9 +25,7 @@
 
 namespace fahrenheit {
 
-struct system_tag : public ordinal<110> { };
-
-typedef homogeneous_system<system_tag>  system;
+typedef make_system<fahrenheit_tag>::type system;
 
 typedef unit<temperature_type,system>   temperature;
 
@@ -36,14 +34,8 @@
 
 } // namespace fahrenheit
 
-template<> struct base_unit_info<temperature_dim,fahrenheit::system_tag>
-{
-    static std::string name()               { return "Fahrenheit"; }
-    static std::string symbol()             { return "F"; }
-};
-
 } // namespace units
 
 } // namespace boost
 
-#endif // BOOST_UNITS_FAHRENHEIT_HPP
\ No newline at end of file
+#endif // BOOST_UNITS_FAHRENHEIT_HPP

Modified: sandbox/units/libs/units/example/unit_example_20.cpp
==============================================================================
--- sandbox/units/libs/units/example/unit_example_20.cpp	(original)
+++ sandbox/units/libs/units/example/unit_example_20.cpp	2007-05-28 18:55:04 EDT (Mon, 28 May 2007)
@@ -44,6 +44,8 @@
 #include <boost/units/systems/si/temperature.hpp>
 #include <boost/units/detail/utility.hpp>
 
+BOOST_UNITS_DEFINE_AFFINE_CONVERSION(boost::units::fahrenheit_tag::unit_type, boost::units::kelvin_tag::unit_type, double, 273.15 + 5.0 / 9.0 * 32.0);
+
 using namespace boost::units;
 
 namespace boost {
@@ -67,47 +69,53 @@
     public mpl::true_
 { };
 
-template<class Y>
-class conversion_helper< quantity<unit<temperature_type,fahrenheit::system>,absolute<Y> >,
-                         quantity<unit<temperature_type,SI::system>,absolute<Y> > >
-{
-    public:
-        typedef unit<temperature_type,fahrenheit::system>   unit1_type;
-        typedef unit<temperature_type,SI::system>           unit2_type;
-        
-        typedef quantity<unit1_type,absolute<Y> >           from_quantity_type;
-        typedef quantity<unit2_type,absolute<Y> >           to_quantity_type;
-
-        static
-        to_quantity_type
-        convert(const from_quantity_type& source)
-        {
-            const typename from_quantity_type::value_type&   in(source.value());
-            
-            return to_quantity_type::from_value((in.value()-32)*(5.0/9.0) + 273.15);
-        }
-};
-
-template<class Y>
-class conversion_helper< quantity<unit<temperature_type,fahrenheit::system>,Y>,
-                         quantity<unit<temperature_type,SI::system>,Y> >
-{
-    public:
-        typedef unit<temperature_type,fahrenheit::system>   unit1_type;
-        typedef unit<temperature_type,SI::system>           unit2_type;
-        
-        typedef quantity<unit1_type,Y>                      from_quantity_type;
-        typedef quantity<unit2_type,Y>                      to_quantity_type;
+template<>
+struct is_implicitly_convertible<absolute< unit<temperature_type,fahrenheit::system> >,
+                                  absolute< unit<temperature_type,SI::system> > > : 
+    public mpl::true_
+{ };
 
-        static
-        to_quantity_type
-        convert(const from_quantity_type& source)
-        {
-            const typename from_quantity_type::value_type&   in(source.value());
-            
-            return to_quantity_type::from_value(in*(5.0/9.0));
-        }
-};
+//template<class Y>
+//class conversion_helper< quantity<unit<temperature_type,fahrenheit::system>,absolute<Y> >,
+//                         quantity<unit<temperature_type,SI::system>,absolute<Y> > >
+//{
+//    public:
+//        typedef unit<temperature_type,fahrenheit::system>   unit1_type;
+//        typedef unit<temperature_type,SI::system>           unit2_type;
+//        
+//        typedef quantity<unit1_type,absolute<Y> >           from_quantity_type;
+//        typedef quantity<unit2_type,absolute<Y> >           to_quantity_type;
+//
+//        static
+//        to_quantity_type
+//        convert(const from_quantity_type& source)
+//        {
+//            const typename from_quantity_type::value_type&   in(source.value());
+//            
+//            return to_quantity_type::from_value((in.value()-32)*(5.0/9.0) + 273.15);
+//        }
+//};
+//
+//template<class Y>
+//class conversion_helper< quantity<unit<temperature_type,fahrenheit::system>,Y>,
+//                         quantity<unit<temperature_type,SI::system>,Y> >
+//{
+//    public:
+//        typedef unit<temperature_type,fahrenheit::system>   unit1_type;
+//        typedef unit<temperature_type,SI::system>           unit2_type;
+//        
+//        typedef quantity<unit1_type,Y>                      from_quantity_type;
+//        typedef quantity<unit2_type,Y>                      to_quantity_type;
+//
+//        static
+//        to_quantity_type
+//        convert(const from_quantity_type& source)
+//        {
+//            const typename from_quantity_type::value_type&   in(source.value());
+//            
+//            return to_quantity_type::from_value(in*(5.0/9.0));
+//        }
+//};
 
 } // namespace units
 
@@ -117,16 +125,16 @@
 {
     std::stringstream sstream1, sstream2;
     
-    quantity<fahrenheit::temperature,absolute<> >   T1p(absolute<>(32)*fahrenheit::degrees);
-    quantity<fahrenheit::temperature>               T1v(32*fahrenheit::degrees);
+    quantity<absolute<fahrenheit::temperature> >   T1p(32.0*absolute<fahrenheit::temperature>());
+    quantity<fahrenheit::temperature>               T1v(32.0*fahrenheit::degrees);
     
-    quantity<SI::temperature,absolute<> >           T2p(T1p);
-    quantity<SI::temperature,absolute<> >           T3p = T1p;
+    quantity<absolute<SI::temperature> >           T2p(T1p);
+    quantity<absolute<SI::temperature> >           T3p = T1p;
     quantity<SI::temperature>                       T2v(T1v);
     quantity<SI::temperature>                       T3v = T1v;
     
-    typedef conversion_helper<quantity<fahrenheit::temperature,absolute<> >,
-                              quantity<SI::temperature,absolute<> > >           absolute_conv_type;
+    typedef conversion_helper<quantity<absolute<fahrenheit::temperature> >,
+                              quantity<absolute<SI::temperature> > >           absolute_conv_type;
     typedef conversion_helper<quantity<fahrenheit::temperature,double>,
                               quantity<SI::temperature,double> >                relative_conv_type;