[Boost-commit] svn:boost r46632 - in trunk: boost/units boost/units/detail libs/units/example

From: steven_at_[hidden]
Date: 2008-06-23 23:04:51

Author: steven_watanabe
Date: 2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
New Revision: 46632
URL: http://svn.boost.org/trac/boost/changeset/46632

Log:
Reduced the number of template instantiations
Text files modified: 
   trunk/boost/units/derived_dimension.hpp               |    74 +-                                      
   trunk/boost/units/detail/conversion_impl.hpp          |    75 +-                                      
   trunk/boost/units/detail/dimension_impl.hpp           |   209 +++----                                 
   trunk/boost/units/detail/heterogeneous_conversion.hpp |   104 +--                                     
   trunk/boost/units/detail/linear_algebra.hpp           |  1069 ++++++++++++++++++--------------------- 
   trunk/boost/units/detail/push_front_if.hpp            |     7                                         
   trunk/boost/units/detail/push_front_or_add.hpp        |    13                                         
   trunk/boost/units/detail/sort.hpp                     |   127 +---                                    
   trunk/boost/units/detail/unscale.hpp                  |     8                                         
   trunk/boost/units/dimension.hpp                       |    14                                         
   trunk/boost/units/heterogeneous_system.hpp            |    28                                         
   trunk/boost/units/io.hpp                              |    32                                         
   trunk/boost/units/make_system.hpp                     |    20                                         
   trunk/libs/units/example/lambda.cpp                   |     4                                         
   14 files changed, 826 insertions(+), 958 deletions(-)

Modified: trunk/boost/units/derived_dimension.hpp
==============================================================================
--- trunk/boost/units/derived_dimension.hpp	(original)
+++ trunk/boost/units/derived_dimension.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -11,8 +11,6 @@
 #ifndef BOOST_UNITS_DERIVED_DIMENSION_HPP
 #define BOOST_UNITS_DERIVED_DIMENSION_HPP
 
-#include <boost/mpl/list.hpp>
-
 #include <boost/units/dim.hpp>
 #include <boost/units/dimension.hpp>
 #include <boost/units/static_rational.hpp>
@@ -38,14 +36,14 @@
     typedef detail::unspecified type;
 #else
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> >,
-                                    dim< DT4,static_rational<E4> >,
-                                    dim< DT5,static_rational<E5> >,
-                                    dim< DT6,static_rational<E6> >,
-                                    dim< DT7,static_rational<E7> >,
-                                    dim< DT8,static_rational<E8> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >,
+                         list< dim< DT4,static_rational<E4> >,
+                         list< dim< DT5,static_rational<E5> >,
+                         list< dim< DT6,static_rational<E6> >,
+                         list< dim< DT7,static_rational<E7> >,
+                         list< dim< DT8,static_rational<E8> >, dimensionless_type > > > > > > > > >::type type;
 #endif
 };
 
@@ -62,7 +60,7 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >, dimensionless_type > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -79,8 +77,8 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >, dimensionless_type > > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -98,9 +96,9 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >, dimensionless_type > > > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -119,10 +117,10 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> >,
-                                    dim< DT4,static_rational<E4> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >,
+                         list< dim< DT4,static_rational<E4> >, dimensionless_type > > > > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -142,11 +140,11 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> >,
-                                    dim< DT4,static_rational<E4> >,
-                                    dim< DT5,static_rational<E5> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >,
+                         list< dim< DT4,static_rational<E4> >,
+                         list< dim< DT5,static_rational<E5> >, dimensionless_type > > > > > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -167,12 +165,12 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> >,
-                                    dim< DT4,static_rational<E4> >,
-                                    dim< DT5,static_rational<E5> >,
-                                    dim< DT6,static_rational<E6> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >,
+                         list< dim< DT4,static_rational<E4> >,
+                         list< dim< DT5,static_rational<E5> >,
+                         list< dim< DT6,static_rational<E6> >, dimensionless_type > > > > > > >::type type;
 };
 
 /// INTERNAL ONLY
@@ -194,13 +192,13 @@
     dimensionless_type,0>
 {
     typedef typename 
-    make_dimension_list< mpl::list< dim< DT1,static_rational<E1> >,
-                                    dim< DT2,static_rational<E2> >,
-                                    dim< DT3,static_rational<E3> >,
-                                    dim< DT4,static_rational<E4> >,
-                                    dim< DT5,static_rational<E5> >,
-                                    dim< DT6,static_rational<E6> >,
-                                    dim< DT7,static_rational<E7> > > >::type type;
+    make_dimension_list< list< dim< DT1,static_rational<E1> >,
+                         list< dim< DT2,static_rational<E2> >,
+                         list< dim< DT3,static_rational<E3> >,
+                         list< dim< DT4,static_rational<E4> >,
+                         list< dim< DT5,static_rational<E5> >,
+                         list< dim< DT6,static_rational<E6> >,
+                         list< dim< DT7,static_rational<E7> >, dimensionless_type > > > > > > > >::type type;
 };
 
 } // namespace units

Modified: trunk/boost/units/detail/conversion_impl.hpp
==============================================================================
--- trunk/boost/units/detail/conversion_impl.hpp	(original)
+++ trunk/boost/units/detail/conversion_impl.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -12,10 +12,7 @@
 #define BOOST_UNITS_DETAIL_CONVERSION_IMPL_HPP
 
 #include <boost/mpl/bool.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/mpl/divides.hpp>
 #include <boost/preprocessor/seq/enum.hpp>
 #include <boost/type_traits/is_same.hpp>
@@ -229,11 +226,11 @@
     template<class Begin>
     struct apply
     {
-        typedef typename mpl::deref<Begin>::type source_pair;
+        typedef typename Begin::item source_pair;
         typedef typename source_pair::value_type exponent;
         typedef typename source_pair::tag_type source;
         typedef typename get_default_conversion<source>::type new_source;
-        typedef typename get_default_conversion_impl<N-1>::template apply<typename mpl::next<Begin>::type> next_iteration;
+        typedef typename get_default_conversion_impl<N-1>::template apply<typename Begin::next> next_iteration;
         typedef typename multiply_typeof_helper<typename power_typeof_helper<new_source, exponent>::type, typename next_iteration::unit_type>::type unit_type;
         typedef call_base_unit_converter<source, new_source> conversion;
         typedef typename multiply_typeof_helper<typename conversion::type, typename next_iteration::type>::type type;
@@ -276,7 +273,7 @@
     struct apply {
         typedef typename reduce_unit<typename get_default_conversion<Source>::type>::type new_source;
         typedef typename Dest::system_type::type system_list;
-        typedef typename get_default_conversion_impl<mpl::size<system_list>::value>::template apply<typename mpl::begin<system_list>::type> impl;
+        typedef typename get_default_conversion_impl<system_list::size::value>::template apply<system_list> impl;
         typedef typename impl::unit_type new_dest;
         typedef call_base_unit_converter<Source, new_source> start;
         typedef conversion_factor_helper<new_source, new_dest> conversion;
@@ -334,10 +331,10 @@
     struct apply
     {
         typedef typename conversion_impl<N-1>::template apply<
-            typename mpl::next<Begin>::type,
+            typename Begin::next,
             DestinationSystem
         > next_iteration;
-        typedef typename mpl::deref<Begin>::type unit_pair;
+        typedef typename Begin::item unit_pair;
         typedef typename unit_pair::tag_type unit;
         typedef typename unit::dimension_type dimensions;
         typedef typename reduce_unit<units::unit<dimensions, DestinationSystem> >::type reduced_unit;
@@ -374,8 +371,8 @@
     static destination_type convert(const quantity<unit<D, homogeneous_system<L1> >, T1>& source)
     {
         return(destination_type::from_value(source.value() * 
-            detail::conversion_impl<mpl::size<unit_list>::value>::template apply<
-                typename mpl::begin<unit_list>::type,
+            detail::conversion_impl<unit_list::size::value>::template apply<
+                unit_list,
                 homogeneous_system<L2>
             >::value()
             ));
@@ -392,8 +389,8 @@
     static destination_type convert(const quantity<unit<D, heterogeneous_system<L1> >, T1>& source)
     {
         return(destination_type::from_value(source.value() * 
-            detail::conversion_impl<mpl::size<typename L1::type>::value>::template apply<
-                typename mpl::begin<typename L1::type>::type,
+            detail::conversion_impl<L1::type::size::value>::template apply<
+                typename L1::type,
                 homogeneous_system<L2>
             >::value() *
             eval_scale_list<typename L1::scale>::value()
@@ -414,8 +411,8 @@
     static destination_type convert(const quantity<unit<D, homogeneous_system<L1> >, T1>& source)
     {
         return(destination_type::from_value(source.value() /
-            (detail::conversion_impl<mpl::size<typename L2::type>::value>::template apply<
-                typename mpl::begin<typename L2::type>::type,
+            (detail::conversion_impl<L2::type::size::value>::template apply<
+                typename L2::type,
                 homogeneous_system<L1>
             >::value() *
             eval_scale_list<typename L2::scale>::value()
@@ -435,13 +432,13 @@
     /// INTERNAL ONLY
     typedef quantity<unit<D, heterogeneous_system<S2> >, T2> destination_type;
     /// INTERNAL ONLY
-    typedef typename detail::extract_base_units<mpl::size<typename S1::type>::value>::template apply<
-        typename mpl::begin<typename S1::type>::type,
-        mpl::list0<>
+    typedef typename detail::extract_base_units<S1::type::size::value>::template apply<
+        typename S1::type,
+        dimensionless_type
     >::type from_base_units;
     /// INTERNAL ONLY
-    typedef typename detail::extract_base_units<mpl::size<typename S2::type>::value>::template apply<
-        typename mpl::begin<typename S2::type>::type,
+    typedef typename detail::extract_base_units<S2::type::size::value>::template apply<
+        typename S2::type,
         from_base_units
     >::type all_base_units;
     /// INTERNAL ONLY
@@ -451,12 +448,12 @@
     static destination_type convert(const source_type& source)
     {
         return(destination_type::from_value(source.value() * 
-            (detail::conversion_impl<mpl::size<typename S1::type>::value>::template apply<
-                typename mpl::begin<typename S1::type>::type,
+            (detail::conversion_impl<S1::type::size::value>::template apply<
+                typename S1::type,
                 system
             >::value() * eval_scale_list<result_scale>::value() /
-            detail::conversion_impl<mpl::size<typename S2::type>::value>::template apply<
-                typename mpl::begin<typename S2::type>::type,
+            detail::conversion_impl<S2::type::size::value>::template apply<
+                typename S2::type,
                 system
             >::value()
             )
@@ -474,8 +471,8 @@
 {
     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,
+    typedef typename detail::conversion_impl<unit_list::size::value>::template apply<
+        unit_list,
         homogeneous_system<L2>
     > impl;
     typedef typename impl::type type;
@@ -488,8 +485,8 @@
 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,
+    typedef typename detail::conversion_impl<L1::type::size::value>::template apply<
+        typename L1::type,
         homogeneous_system<L2>
     > impl;
     typedef eval_scale_list<typename L1::scale> scale;
@@ -506,8 +503,8 @@
 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,
+    typedef typename detail::conversion_impl<L2::type::size::value>::template apply<
+        typename L2::type,
         homogeneous_system<L1>
     > impl;
     typedef eval_scale_list<typename L2::scale> scale;
@@ -524,23 +521,23 @@
 struct conversion_factor_helper<unit<D, heterogeneous_system<S1> >, unit<D, heterogeneous_system<S2> > >
 {
     /// INTERNAL ONLY
-    typedef typename detail::extract_base_units<mpl::size<typename S1::type>::value>::template apply<
-        typename mpl::begin<typename S1::type>::type,
-        mpl::list0<>
+    typedef typename detail::extract_base_units<S1::type::size::value>::template apply<
+        typename S1::type,
+        dimensionless_type
     >::type from_base_units;
     /// INTERNAL ONLY
-    typedef typename detail::extract_base_units<mpl::size<typename S2::type>::value>::template apply<
-        typename mpl::begin<typename S2::type>::type,
+    typedef typename detail::extract_base_units<S2::type::size::value>::template apply<
+        typename S2::type,
         from_base_units
     >::type all_base_units;
     /// INTERNAL ONLY
     typedef typename detail::make_homogeneous_system<all_base_units>::type system;
-    typedef typename detail::conversion_impl<mpl::size<typename S1::type>::value>::template apply<
-        typename mpl::begin<typename S1::type>::type,
+    typedef typename detail::conversion_impl<S1::type::size::value>::template apply<
+        typename S1::type,
         system
     > conversion1;
-    typedef typename detail::conversion_impl<mpl::size<typename S2::type>::value>::template apply<
-        typename mpl::begin<typename S2::type>::type,
+    typedef typename detail::conversion_impl<S2::type::size::value>::template apply<
+        typename S2::type,
         system
     > conversion2;
     typedef eval_scale_list<typename mpl::divides<typename S1::scale, typename S2::scale>::type> scale;

Modified: trunk/boost/units/detail/dimension_impl.hpp
==============================================================================
--- trunk/boost/units/detail/dimension_impl.hpp	(original)
+++ trunk/boost/units/detail/dimension_impl.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -16,7 +16,6 @@
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/list.hpp>
 #include <boost/mpl/next.hpp>
-#include <boost/mpl/push_front.hpp>
 #include <boost/mpl/size.hpp>
 #include <boost/mpl/less.hpp>
 
@@ -37,118 +36,102 @@
 
 namespace detail {
 
-template<bool second_is_less>
-struct sort_dims_conditional_swap;
+template<int N>
+struct insertion_sort_dims_insert;
+
+template<bool is_greater>
+struct insertion_sort_dims_comparison_impl;
 
+// have to recursively add the element to the next sequence.
 template<>
-struct sort_dims_conditional_swap<true>
-{
-    template<class T0, class T1>
-    struct apply
-    {
-        typedef T1 first;
-        typedef T0 second;
+struct insertion_sort_dims_comparison_impl<true> {
+    template<class Begin, int N, class T>
+    struct apply {
+        typedef list<
+            typename Begin::item,
+            typename insertion_sort_dims_insert<N - 1>::template apply<
+                typename Begin::next,
+                T
+            >::type
+        > type;
     };
 };
 
+// either prepend the current element or join it to
+// the first remaining element of the sequence.
 template<>
-struct sort_dims_conditional_swap<false>
-{
-    template<class T0, class T1>
-    struct apply
-    {
-        typedef T0 first;
-        typedef T1 second;
+struct insertion_sort_dims_comparison_impl<false> {
+    template<class Begin, int N, class T>
+    struct apply {
+        typedef typename push_front_or_add<Begin, T>::type type;
     };
 };
 
 template<int N>
-struct sort_dims_pass_impl
-{
-    template<class Begin, class Current>
-    struct apply
-    {
-        typedef typename mpl::deref<Begin>::type val;
-        typedef typename sort_dims_conditional_swap<mpl::less<val, Current>::value>::template apply<Current, val> pair;
-        typedef typename sort_dims_pass_impl<N-1>::template apply<typename mpl::next<Begin>::type, typename pair::second> next;
-        typedef typename push_front_or_add<typename next::type, typename pair::first>::type type;
-        enum { value = next::value || mpl::less<val, Current>::value };
+struct insertion_sort_dims_insert {
+    template<class Begin, class T>
+    struct apply {
+        typedef typename insertion_sort_dims_comparison_impl<mpl::less<typename Begin::item, T>::value>::template apply<
+            Begin,
+            N,
+            T
+        >::type type;
     };
 };
 
 template<>
-struct sort_dims_pass_impl<0>
-{
-    template<class Begin, class Current>
-    struct apply
-    {
-        typedef typename mpl::push_front<dimensionless_type, Current>::type type;
-        enum { value = false };
+struct insertion_sort_dims_insert<0> {
+    template<class Begin, class T>
+    struct apply {
+        typedef list<T, dimensionless_type> type;
     };
 };
 
-template<bool>
-struct sort_dims_impl;
-
-template<>
-struct sort_dims_impl<true>
-{
-    template<class T>
-    struct apply
-    {
-        typedef typename mpl::begin<T>::type begin;
-        typedef typename sort_dims_pass_impl<mpl::size<T>::value - 1>::template apply<
-            typename mpl::next<begin>::type,
-            typename mpl::deref<begin>::type
-        > single_pass;
-        typedef typename sort_dims_impl<(single_pass::value)>::template apply<typename single_pass::type>::type type;
+template<int N>
+struct insertion_sort_dims_mpl_sequence {
+    template<class Begin>
+    struct apply {
+        typedef typename insertion_sort_dims_mpl_sequence<N - 1>::template apply<typename mpl::next<Begin>::type>::type next;
+        typedef typename insertion_sort_dims_insert<(next::size::value)>::template apply<next, typename mpl::deref<Begin>::type>::type type;
     };
 };
 
 template<>
-struct sort_dims_impl<false>
-{
-    template<class T>
-    struct apply
-    {
-        typedef T type;
+struct insertion_sort_dims_mpl_sequence<0> {
+    template<class Begin>
+    struct apply {
+        typedef dimensionless_type type;
     };
 };
 
 template<int N>
-struct sort_dims_one_or_zero
-{
-    template<class T>
-    struct apply
-    {
-        typedef typename sort_dims_impl<true>::template apply<T>::type type;
+struct insertion_sort_dims_impl {
+    template<class Begin>
+    struct apply {
+        typedef typename insertion_sort_dims_impl<N - 1>::template apply<typename Begin::next>::type next;
+        typedef typename insertion_sort_dims_insert<(next::size::value)>::template apply<next, typename Begin::item>::type type;
     };
 };
 
 template<>
-struct sort_dims_one_or_zero<0>
-{
-    template<class T>
-    struct apply
-    {
+struct insertion_sort_dims_impl<0> {
+    template<class Begin>
+    struct apply {
         typedef dimensionless_type type;
     };
 };
 
-template<>
-struct sort_dims_one_or_zero<1>
+template<class T>
+struct sort_dims
 {
-    template<class T>
-    struct apply
-    {
-        typedef typename mpl::push_front<dimensionless_type, typename mpl::front<T>::type>::type type;
-    };
+    typedef typename insertion_sort_dims_mpl_sequence<mpl::size<T>::value>::template apply<typename mpl::begin<T>::type>::type type;
 };
 
-template<class T>
-struct sort_dims
+
+template<class T, class Next>
+struct sort_dims<list<T, Next> >
 {
-    typedef typename sort_dims_one_or_zero<mpl::size<T>::value>::template apply<T>::type type;
+    typedef typename insertion_sort_dims_impl<list<T, Next>::size::value>::template apply<list<T, Next> >::type type;
 };
 
 /// sorted sequences can be merged in linear time
@@ -164,13 +147,13 @@
     template<typename Begin1, typename Begin2, int N1, int N2>
     struct apply
     {
-        typedef typename mpl::push_front<
+        typedef list<
+            typename Begin1::item,
             typename merge_dimensions_impl<N1 - 1, N2>::template apply<
-                typename boost::mpl::next<Begin1>::type,
+                typename Begin1::next,
                 Begin2
-            >::type,
-            typename boost::mpl::deref<Begin1>::type
-        >::type type;
+            >::type
+        > type;
     };
 };
 
@@ -179,13 +162,13 @@
     template<typename Begin1, typename Begin2, int N1, int N2>
     struct apply
     {
-        typedef typename mpl::push_front<
+        typedef list<
+            typename Begin2::item,
             typename merge_dimensions_impl<N2 - 1, N1>::template apply<
-                typename boost::mpl::next<Begin2>::type,
+                typename Begin2::next,
                 Begin1
-            >::type,
-            typename boost::mpl::deref<Begin2>::type
-        >::type type;
+            >::type
+        > type;
     };
 };
 
@@ -194,11 +177,11 @@
     template<typename Begin1, typename Begin2, int N1, int N2>
     struct apply
     {
-        typedef typename mpl::plus<typename boost::mpl::deref<Begin1>::type, typename boost::mpl::deref<Begin2>::type>::type combined;
+        typedef typename mpl::plus<typename Begin1::item, typename Begin2::item>::type combined;
         typedef typename push_front_if<!is_empty_dim<combined>::value>::template apply<
             typename merge_dimensions_impl<N1 - 1, N2 - 1>::template apply<
-                typename boost::mpl::next<Begin1>::type,
-                typename boost::mpl::next<Begin2>::type
+                typename Begin1::next,
+                typename Begin2::next
             >::type,
             combined
         >::type type;
@@ -210,8 +193,8 @@
     template<typename Begin1, typename Begin2>
     struct apply
     {
-        typedef typename boost::mpl::deref<Begin1>::type dim1;
-        typedef typename boost::mpl::deref<Begin2>::type dim2;
+        typedef typename Begin1::item dim1;
+        typedef typename Begin2::item dim2;
 
         typedef typename merge_dimensions_func<(mpl::less<dim1,dim2>::value == true),
                 (mpl::less<dim2,dim1>::value == true)>::template apply<
@@ -226,11 +209,11 @@
 template<typename Sequence1, typename Sequence2>
 struct merge_dimensions
 {
-    typedef typename detail::merge_dimensions_impl<boost::mpl::size<Sequence1>::value, 
-                                                   boost::mpl::size<Sequence2>::value>::template 
+    typedef typename detail::merge_dimensions_impl<Sequence1::size::value, 
+                                                   Sequence2::size::value>::template 
         apply<
-            typename boost::mpl::begin<Sequence1>::type,
-            typename boost::mpl::begin<Sequence2>::type
+            Sequence1,
+            Sequence2
         >::type type;
 };
 
@@ -240,12 +223,12 @@
     template<typename Begin>
     struct apply
     {
-        typedef typename mpl::push_front<
+        typedef list<
+            typename Begin::item,
             typename iterator_to_list<N - 1>::template apply<
-                typename boost::mpl::next<Begin>::type
-            >::type,
-            typename boost::mpl::deref<Begin>::type
-        >::type type;
+                typename Begin::next
+            >::type
+        > type;
     };
 };
 
@@ -293,12 +276,12 @@
 {
     template<typename Begin>
     struct apply {
-        typedef typename boost::mpl::push_front<
+        typedef list<
+            typename mpl::negate<typename Begin::item>::type,
             typename static_inverse_impl<N - 1>::template apply<
-                typename boost::mpl::next<Begin>::type
-            >::type,
-            typename mpl::negate<typename boost::mpl::deref<Begin>::type>::type
-        >::type type;
+                typename Begin::next
+            >::type
+        > type;
     };
 };
 
@@ -318,10 +301,10 @@
     template<typename Begin, typename Ex>
     struct apply
     {
-        typedef typename mpl::push_front<
-            typename detail::static_power_impl<N - 1>::template apply<typename mpl::next<Begin>::type, Ex>::type,
-            typename mpl::times<typename mpl::deref<Begin>::type, Ex>::type
-        >::type type;
+        typedef list<
+            typename mpl::times<typename Begin::item, Ex>::type,
+            typename detail::static_power_impl<N - 1>::template apply<typename Begin::next, Ex>::type
+        > type;
     };
 };
 
@@ -339,10 +322,10 @@
 struct static_root_impl {
     template<class Begin, class Ex>
     struct apply {
-        typedef typename mpl::push_front<
-            typename detail::static_root_impl<N - 1>::template apply<typename mpl::next<Begin>::type, Ex>::type,
-            typename mpl::divides<typename mpl::deref<Begin>::type, Ex>::type
-        >::type type;
+        typedef list<
+            typename mpl::divides<typename Begin::item, Ex>::type,
+            typename detail::static_root_impl<N - 1>::template apply<typename Begin::next, Ex>::type
+        > type;
     };
 };
 

Modified: trunk/boost/units/detail/heterogeneous_conversion.hpp
==============================================================================
--- trunk/boost/units/detail/heterogeneous_conversion.hpp	(original)
+++ trunk/boost/units/detail/heterogeneous_conversion.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -11,14 +11,8 @@
 #ifndef BOOST_UNITS_DETAIL_HETEROGENEOUS_CONVERSION_HPP
 #define BOOST_UNITS_DETAIL_HETEROGENEOUS_CONVERSION_HPP
 
-#include <boost/mpl/list/list0.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/push_front.hpp>
-
-#include <boost/mpl/print.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/mpl/times.hpp>
 
 #include <boost/units/static_rational.hpp>
 #include <boost/units/homogeneous_system.hpp>
@@ -33,7 +27,7 @@
 struct solve_end {
     template<class Begin, class Y>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type type;
     };
 };
 
@@ -43,14 +37,14 @@
 struct solve_normal {
     template<class Begin, class Y>
     struct apply {
-        typedef typename mpl::next<Begin>::type next;
-        typedef typename mpl::push_front<
-            typename Next::template apply<next, Y>::type,
+        typedef typename Begin::next next;
+        typedef list<
             typename mpl::minus<
                 typename mpl::times<X1, Y>::type,
-                typename mpl::times<X2, typename mpl::deref<Begin>::type>::type
-            >::type
-        >::type type;
+                typename mpl::times<X2, typename Begin::item>::type
+            >::type,
+            typename Next::template apply<next, Y>::type
+        > type;
     };
 };
 
@@ -58,10 +52,10 @@
 struct solve_leading_zeroes {
     template<class Begin>
     struct apply {
-        typedef typename mpl::push_front<
-            typename Next::template apply<typename mpl::next<Begin>::type>::type,
-            typename mpl::deref<Begin>::type
-        >::type type;
+        typedef list<
+            typename Begin::item,
+            typename Next::template apply<typename Begin::next>::type
+        > type;
     };
     typedef solve_leading_zeroes type;
 };
@@ -76,8 +70,8 @@
     template<class Begin>
     struct apply {
         typedef typename Next::template apply<
-            typename mpl::next<Begin>::type,
-            typename mpl::deref<Begin>::type
+            typename Begin::next,
+            typename Begin::item
         >::type type;
     };
 };
@@ -86,10 +80,10 @@
 struct solve_internal_zero {
     template<class Begin, class Y>
     struct apply {
-        typedef typename mpl::push_front<
-            typename Next::template apply<typename mpl::next<Begin>::type, Y>::type,
-            typename mpl::deref<Begin>::type
-        >::type type;
+        typedef list<
+            typename Begin::item,
+            typename Next::template apply<typename Begin::next, Y>::type
+        > type;
     };
 };
 
@@ -114,9 +108,9 @@
     template<class Begin, class X>
     struct apply {
         typedef typename make_solve_list_internal_zero<
-            typename mpl::deref<Begin>::type
+            typename Begin::item
         >::template apply<
-            typename make_solve_list_normal<N-1>::template apply<typename mpl::next<Begin>::type, X>::type,
+            typename make_solve_list_normal<N-1>::template apply<typename Begin::next, X>::type,
             X
         >::type type;
     };
@@ -139,8 +133,8 @@
     struct apply {
         typedef solve_first_non_zero<
             typename make_solve_list_normal<N-1>::template apply<
-                typename mpl::next<Begin>::type,
-                typename mpl::deref<Begin>::type
+                typename Begin::next,
+                typename Begin::item
             >::type
         > type;
     };
@@ -152,7 +146,7 @@
     struct apply {
         typedef typename solve_leading_zeroes<
             typename make_solve_list_leading_zeroes<N-1>::template apply<
-                typename mpl::next<Begin>::type
+                typename Begin::next
             >::type
         >::type type;
     };
@@ -162,7 +156,7 @@
 struct make_solve_list_leading_zeroes {
     template<class Begin>
     struct apply {
-        typedef typename make_solve_list_first_non_zero<typename mpl::deref<Begin>::type>::template apply<Begin, N>::type type;
+        typedef typename make_solve_list_first_non_zero<typename Begin::item>::template apply<Begin, N>::type type;
     };
 };
 
@@ -178,9 +172,9 @@
 struct try_add_unit_impl {
     template<class Begin, class L>
     struct apply {
-        typedef typename try_add_unit_impl<N-1>::template apply<typename mpl::next<Begin>::type, L>::type next;
-        typedef typename mpl::deref<Begin>::type::template apply<typename mpl::begin<next>::type>::type type;
-        BOOST_STATIC_ASSERT((mpl::size<next>::value - 1 == mpl::size<type>::value));
+        typedef typename try_add_unit_impl<N-1>::template apply<typename Begin::next, L>::type next;
+        typedef typename Begin::item::template apply<next>::type type;
+        BOOST_STATIC_ASSERT((next::size::value - 1 == type::size::value));
     };
 };
 
@@ -203,9 +197,9 @@
     template<class Begin, class Current, class Units, class Dimensions, int N>
     struct apply {
         typedef typename make_homogeneous_system_impl<N-1>::template apply<
-            typename mpl::next<Begin>::type,
-            typename mpl::push_front<Current, T>::type,
-            typename mpl::push_front<Units, typename mpl::deref<Begin>::type>::type,
+            typename Begin::next,
+            list<T, Current>,
+            list<typename Begin::item, Units>,
             Dimensions
         >::type type;
     };
@@ -215,7 +209,7 @@
 struct make_homogeneous_system_func<T, true> {
     template<class Begin, class Current, class Units, class Dimensions, int N>
     struct apply {
-        typedef typename mpl::push_front<Units, typename mpl::deref<Begin>::type>::type type;
+        typedef list<typename Begin::item, Units> type;
     };
 };
 
@@ -224,7 +218,7 @@
     template<class Begin, class Current, class Units, class Dimensions, int N>
     struct apply {
         typedef typename make_homogeneous_system_impl<N-1>::template apply<
-            typename mpl::next<Begin>::type,
+            typename Begin::next,
             Current,
             Units,
             Dimensions
@@ -237,7 +231,7 @@
     template<class Begin, class Current, class Units, class Dimensions, int N>
     struct apply {
         typedef typename make_homogeneous_system_impl<N-1>::template apply<
-            typename mpl::next<Begin>::type,
+            typename Begin::next,
             Current,
             Units,
             Dimensions
@@ -249,15 +243,15 @@
 struct make_homogeneous_system_impl {
     template<class Begin, class Current, class Units, class Dimensions>
     struct apply {
-        typedef typename expand_dimensions<mpl::size<Dimensions>::value>::template apply<
-            typename mpl::begin<Dimensions>::type,
-            typename mpl::begin<typename mpl::deref<Begin>::type::dimension_type>::type
+        typedef typename expand_dimensions<Dimensions::size::value>::template apply<
+            Dimensions,
+            typename Begin::item::dimension_type
         >::type dimensions;
-        typedef typename try_add_unit_impl<mpl::size<Current>::value>::template apply<typename mpl::begin<Current>::type, dimensions>::type new_element;
-        typedef typename make_solve_list_leading_zeroes<mpl::size<new_element>::value>::template apply<typename mpl::begin<new_element>::type>::type new_func;
+        typedef typename try_add_unit_impl<Current::size::value>::template apply<Current, dimensions>::type new_element;
+        typedef typename make_solve_list_leading_zeroes<new_element::size::value>::template apply<new_element>::type new_func;
         typedef typename make_homogeneous_system_func<
             new_func,
-            ((mpl::size<Current>::value)+1) == (mpl::size<Dimensions>::value)
+            ((Current::size::value)+1) == (Dimensions::size::value)
         >::template apply<Begin, Current, Units, Dimensions, N>::type type;
     };
 };
@@ -274,13 +268,13 @@
 struct make_homogeneous_system {
     typedef typename find_base_dimensions<Units>::type base_dimensions;
     typedef homogeneous_system<
-        typename bubble_sort<
+        typename insertion_sort<
             typename make_homogeneous_system_impl<
-                mpl::size<Units>::value
+                Units::size::value
             >::template apply<
-                typename mpl::begin<Units>::type,
-                mpl::list0<>,
-                mpl::list0<>,
+                Units,
+                dimensionless_type,
+                dimensionless_type,
                 base_dimensions
             >::type
         >::type
@@ -291,10 +285,10 @@
 struct extract_base_units {
     template<class Begin, class T>
     struct apply {
-        typedef typename mpl::push_front<
-            typename extract_base_units<N-1>::template apply<typename mpl::next<Begin>::type, T>::type,
-            typename mpl::deref<Begin>::type::tag_type
-        >::type type;
+        typedef list<
+            typename Begin::item::tag_type,
+            typename extract_base_units<N-1>::template apply<typename Begin::next, T>::type
+        > type;
     };
 };
 

Modified: trunk/boost/units/detail/linear_algebra.hpp
==============================================================================
--- trunk/boost/units/detail/linear_algebra.hpp	(original)
+++ trunk/boost/units/detail/linear_algebra.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -12,22 +12,8 @@
 #define BOOST_UNITS_DETAIL_LINEAR_ALGEBRA_HPP
 
 #include <boost/units/static_rational.hpp>
-#include <boost/mpl/list.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/mpl/pop_front.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/size.hpp>
 #include <boost/mpl/next.hpp>
 #include <boost/mpl/arithmetic.hpp>
-#include <boost/mpl/front_inserter.hpp>
-#include <boost/mpl/set.hpp>
-#include <boost/mpl/insert.hpp>
-#include <boost/mpl/greater.hpp>
-#include <boost/mpl/reverse.hpp>
-#include <boost/mpl/advance.hpp>
-#include <boost/mpl/erase.hpp>
-#include <boost/mpl/front.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/assert.hpp>
 
@@ -77,6 +63,24 @@
 
 struct inconsistent {};
 
+// generally useful utilies.
+
+template<int N>
+struct divide_equation {
+    template<class Begin, class Divisor>
+    struct apply {
+        typedef list<typename mpl::divides<typename Begin::item, Divisor>::type, typename divide_equation<N - 1>::template apply<typename Begin::next, Divisor>::type> type;
+    };
+};
+
+template<>
+struct divide_equation<0> {
+    template<class Begin, class Divisor>
+    struct apply {
+        typedef dimensionless_type type;
+    };
+};
+
 // eliminate_from_pair_of_equations takes a pair of
 // equations and eliminates the first variable.
 //
@@ -90,18 +94,18 @@
 struct eliminate_from_pair_of_equations_impl {
     template<class Begin1, class Begin2, class X1, class X2>
     struct apply {
-        typedef typename mpl::push_front<
+        typedef list<
+            typename mpl::minus<
+                typename mpl::times<typename Begin1::item, X2>::type,
+                typename mpl::times<typename Begin2::item, X1>::type
+            >::type,
             typename eliminate_from_pair_of_equations_impl<N - 1>::template apply<
-                typename mpl::next<Begin1>::type,
-                typename mpl::next<Begin2>::type,
+                typename Begin1::next,
+                typename Begin2::next,
                 X1,
                 X2
-            >::type,
-            typename mpl::minus<
-                typename mpl::times<typename mpl::deref<Begin1>::type, X2>::type,
-                typename mpl::times<typename mpl::deref<Begin2>::type, X1>::type
             >::type
-        >::type type;
+        > type;
     };
 };
 
@@ -109,295 +113,436 @@
 struct eliminate_from_pair_of_equations_impl<0> {
     template<class Begin1, class Begin2, class X1, class X2>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type type;
     };
 };
 
 template<class E1, class E2>
 struct eliminate_from_pair_of_equations {
-    typedef typename mpl::begin<E1>::type begin1;
-    typedef typename mpl::begin<E2>::type begin2;
-    typedef typename eliminate_from_pair_of_equations_impl<mpl::size<E1>::value - 1>::template apply<
-        typename mpl::next<begin1>::type,
-        typename mpl::next<begin2>::type,
-        typename mpl::deref<begin1>::type,
-        typename mpl::deref<begin2>::type
+    typedef E1 begin1;
+    typedef E2 begin2;
+    typedef typename eliminate_from_pair_of_equations_impl<(E1::size::value - 1)>::template apply<
+        typename begin1::next,
+        typename begin2::next,
+        typename begin1::item,
+        typename begin2::item
     >::type type;
 };
 
-// Eliminates the first variable from a list of equations
-// returns inconsistent if all its coefficients are 0.  Otherwise
-// recursively calls solve to find the remaining variables
-//
-// list<rational> eliminate(list<equation> system) {
-//     list<equation> result;
-//     equation eliminate_against = null;
-//     for_each(equation e : system) {
-//         if(eliminate_against == null) {
-//             if(e.front() == 0) {
-//                 result = push_front(result, pop_front(e));
-//             } else {
-//                 eliminate_against = e;
-//             }
-//         } else {
-//             result = push_back(result, eliminate_from_pair_of_equations(e,eliminate_against));
-//         }
-//     }
-//     if(eliminate_against == null) {
-//         return(inconsistent);
-//     } else {
-//         list<rational> solution = solve(result);
-//         return(push_front(solution, substitute(eliminate_against,solution)));
-//     }
-// }
+
+
+// Stage 1.  Determine which dimensions should
+// have dummy base units.  For this purpose
+// row reduce the matrix.
 
 template<int N>
-struct elimination_impl {
-    template<class Begin, class Prev, class L>
+struct make_zero_vector {
+    typedef list<static_rational<0>, typename make_zero_vector<N - 1>::type> type;
+};
+template<>
+struct make_zero_vector<0> {
+    typedef dimensionless_type type;
+};
+
+template<int Column, int TotalColumns>
+struct create_row_of_identity {
+    typedef list<static_rational<0>, typename create_row_of_identity<Column - 1, TotalColumns - 1>::type> type;
+};
+template<int TotalColumns>
+struct create_row_of_identity<0, TotalColumns> {
+    typedef list<static_rational<1>, typename make_zero_vector<TotalColumns - 1>::type> type;
+};
+template<int Column>
+struct create_row_of_identity<Column, 0> {
+    // error
+};
+
+template<int RemainingRows>
+struct determine_extra_equations_impl;
+
+template<bool first_is_zero, bool is_last>
+struct determine_extra_equations_skip_zeros_impl;
+
+// not the last row and not zero.
+template<>
+struct determine_extra_equations_skip_zeros_impl<false, false> {
+    template<class RowsBegin, int RemainingRows, int CurrentColumn, int TotalColumns, class Result>
     struct apply {
-        typedef typename mpl::push_front<
-            typename elimination_impl<N-1>::template apply<typename mpl::next<Begin>::type, Prev, L>::type,
-            typename eliminate_from_pair_of_equations<typename mpl::deref<Begin>::type,Prev>::type
-        >::type type;
+        // remove the equation being eliminated against from the set of equations.
+        typedef typename determine_extra_equations_impl<RemainingRows - 1>::template apply<typename RowsBegin::next, typename RowsBegin::item>::type next_equations;
+        // since this column was present, strip it out.
+        typedef Result type;
     };
 };
 
+// the last row but not zero.
 template<>
-struct elimination_impl<0> {
-    template<class Begin, class Prev, class L>
+struct determine_extra_equations_skip_zeros_impl<false, true> {
+    template<class RowsBegin, int RemainingRows, int CurrentColumn, int TotalColumns, class Result>
     struct apply {
-        typedef L type;
+        // remove this equation.
+        typedef dimensionless_type next_equations;
+        // since this column was present, strip it out.
+        typedef Result type;
     };
 };
 
+
+// the first columns is zero but it is not the last column.
+// continue with the same loop.
 template<>
-struct elimination_skip_leading_zeros_impl<true, true> {
-    template<class Begin, int N, class L>
+struct determine_extra_equations_skip_zeros_impl<true, false> {
+    template<class RowsBegin, int RemainingRows, int CurrentColumn, int TotalColumns, class Result>
     struct apply {
-        typedef inconsistent type;
+        typedef typename RowsBegin::item current_row;
+        typedef typename determine_extra_equations_skip_zeros_impl<
+            current_row::item::Numerator == 0,
+            RemainingRows == 2  // the next one will be the last.
+        >::template apply<
+            typename RowsBegin::next,
+            RemainingRows - 1,
+            CurrentColumn,
+            TotalColumns,
+            Result
+        > next;
+        typedef list<typename RowsBegin::item::next, typename next::next_equations> next_equations;
+        typedef typename next::type type;
     };
 };
 
+// all the elements in this column are zero.
 template<>
-struct elimination_skip_leading_zeros_impl<true, false> {
-    template<class Begin, int N, class L>
+struct determine_extra_equations_skip_zeros_impl<true, true> {
+    template<class RowsBegin, int RemainingRows, int CurrentColumn, int TotalColumns, class MatrixWithFirstColumnStripped, class Result>
     struct apply {
-        typedef typename mpl::next<Begin>::type next;
-        typedef typename elimination_skip_leading_zeros_impl<
-            boost::is_same<
-                typename mpl::deref<
-                    typename mpl::begin<typename mpl::deref<next>::type>::type
-                >::type,
-                static_rational<0>
-            >::value,
-            N == 2
-        >::template apply<
-            next,
-            N-1,
-            typename mpl::push_front<
-                L,
-                typename mpl::pop_front<typename mpl::deref<Begin>::type>::type
-            >::type
-        >::type type;
+        typedef list<typename RowsBegin::item::next, dimensionless_type> next_equations;
+        typedef list<typename create_row_of_identity<CurrentColumn, TotalColumns>::type, Result> type;
     };
 };
 
-template<class S>
-struct combine_solutions {
-    template<class Iterator>
+template<int RemainingRows>
+struct determine_extra_equations_impl {
+    template<class RowsBegin, class EliminateAgainst>
     struct apply {
-        typedef typename substitute<typename mpl::deref<Iterator>::type, S>::type x;
-        typedef typename mpl::push_front<S, x>::type type;
+        typedef list<
+            typename eliminate_from_pair_of_equations<typename RowsBegin::item, EliminateAgainst>::type,
+            typename determine_extra_equations_impl<RemainingRows-1>::template apply<typename RowsBegin::next, EliminateAgainst>::type
+        > type;
     };
 };
 
 template<>
-struct combine_solutions<inconsistent> {
-    template<class Iterator>
+struct determine_extra_equations_impl<0> {
+    template<class RowsBegin, class EliminateAgainst>
     struct apply {
-        typedef inconsistent type;
+        typedef dimensionless_type type;
     };
 };
 
-template<>
-struct elimination_skip_leading_zeros_impl<false, true> {
-    template<class Begin, int N, class L>
+template<int RemainingColumns, bool is_done>
+struct determine_extra_equations {
+    template<class RowsBegin, int TotalColumns, class Result>
     struct apply {
-        typedef typename elimination_impl<N - 1>::template apply<
-            typename mpl::next<Begin>::type,
-            typename mpl::deref<Begin>::type,
-            L
-        >::type list_type;
-        typedef typename solve<list_type>::type next;
-        typedef typename combine_solutions<next>::template apply<Begin>::type type;
+        typedef typename RowsBegin::item top_row;
+        typedef typename determine_extra_equations_skip_zeros_impl<
+            top_row::item::Numerator == 0,
+            RowsBegin::item::size::value == 1
+        >::template apply<
+            RowsBegin,
+            RowsBegin::size::value,
+            TotalColumns - RemainingColumns,
+            TotalColumns,
+            Result
+        > column_info;
+        typedef typename determine_extra_equations<
+            RemainingColumns - 1,
+            column_info::next_equations::size::value == 0
+        >::template apply<
+            typename column_info::next_equations,
+            TotalColumns,
+            typename column_info::type
+        >::type type;
+    };
+};
+
+template<int RemainingColumns>
+struct determine_extra_equations<RemainingColumns, true> {
+    template<class RowsBegin, int TotalColumns, class Result>
+    struct apply {
+        typedef typename determine_extra_equations<RemainingColumns - 1, true>::template apply<
+            RowsBegin,
+            TotalColumns,
+            list<typename create_row_of_identity<TotalColumns - RemainingColumns, TotalColumns>::type, Result>
+        >::type type;
     };
 };
 
 template<>
-struct elimination_skip_leading_zeros_impl<false, false> {
-    template<class Begin, int N, class L>
+struct determine_extra_equations<0, true> {
+    template<class RowsBegin, int TotalColumns, class Result>
     struct apply {
-        typedef typename elimination_impl<N - 1>::template apply<
-            typename mpl::next<Begin>::type,
-            typename mpl::deref<Begin>::type,
-            L
-        >::type list_type;
-        typedef typename solve<list_type>::type next;
-        typedef typename combine_solutions<next>::template apply<Begin>::type type;
+        typedef Result type;
     };
 };
 
-// finds the vaue of the first variable given the
-// values of all the other variables.
-//
-// rational substitute(equation e, list<rational> solutions) {
-//     rational value = e.back();
-//     for_each(rational x : solutions, rational a : pop_front(pop_back(e))) {
-//         value -= a * x;
-//     }
-//     return(e.front() / value);
-// }
+// Stage 2
+// invert the matrix using Gauss-Jordan elimination
+
+
+template<bool is_zero, bool is_last>
+struct invert_strip_leading_zeroes;
 
 template<int N>
-struct substitute_impl {
-    template<class Begin1, class Begin2>
+struct invert_handle_after_pivot_row;
+
+// When processing column N, none of the first N rows 
+// can be the pivot column.
+template<int N>
+struct invert_handle_inital_rows {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef typename mpl::minus<
-            typename substitute_impl<N-1>::template apply<
-                typename mpl::next<Begin1>::type,
-                typename mpl::next<Begin2>::type
+        typedef typename invert_handle_inital_rows<N - 1>::template apply<
+            typename RowsBegin::next,
+            typename IdentityBegin::next
+        > next;
+        typedef typename RowsBegin::item current_row;
+        typedef typename IdentityBegin::item current_identity_row;
+        typedef typename next::pivot_row pivot_row;
+        typedef typename next::identity_pivot_row identity_pivot_row;
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_row::size::value) - 1>::template apply<
+                typename current_row::next,
+                pivot_row,
+                typename current_row::item,
+                static_rational<1>
             >::type,
-            typename mpl::times<
-                typename mpl::deref<Begin1>::type,
-                typename mpl::deref<Begin2>::type
-            >::type
-        >::type type;
+            typename next::new_matrix
+        > new_matrix;
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_identity_row::size::value)>::template apply<
+                current_identity_row,
+                identity_pivot_row,
+                typename current_row::item,
+                static_rational<1>
+            >::type,
+            typename next::identity_result
+        > identity_result;
     };
 };
 
+// This handles the switch to searching for a pivot column.
+// The pivot row will be propagated up in the typedefs
+// pivot_row and identity_pivot_row.  It is inserted here.
 template<>
-struct substitute_impl<0> {
-    template<class Begin1, class Begin2>
+struct invert_handle_inital_rows<0> {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef typename mpl::deref<Begin1>::type type;
+        typedef typename RowsBegin::item current_row;
+        typedef typename invert_strip_leading_zeroes<
+            (current_row::item::Numerator == 0),
+            (RowsBegin::size::value == 1)
+        >::template apply<
+            RowsBegin,
+            IdentityBegin
+        > next;
+        // results
+        typedef list<typename next::pivot_row, typename next::new_matrix> new_matrix;
+        typedef list<typename next::identity_pivot_row, typename next::identity_result> identity_result;
+        typedef typename next::pivot_row pivot_row;
+        typedef typename next::identity_pivot_row identity_pivot_row;
     };
 };
 
-template<class Equation, class Vars>
-struct substitute {
-    typedef typename mpl::begin<Equation>::type begin;
-    typedef typename mpl::divides<
-        typename substitute_impl<mpl::size<Vars>::value>::template apply<
-            typename mpl::next<begin>::type,
-            typename mpl::begin<Vars>::type
-        >::type,
-        typename mpl::deref<begin>::type
-    >::type type;
+// The first internal element which is not zero.
+template<>
+struct invert_strip_leading_zeroes<false, false> {
+    template<class RowsBegin, class IdentityBegin>
+    struct apply {
+        typedef typename RowsBegin::item current_row;
+        typedef typename current_row::item current_value;
+        typedef typename divide_equation<(current_row::size::value - 1)>::template apply<typename current_row::next, current_value>::type new_equation;
+        typedef typename divide_equation<(IdentityBegin::item::size::value)>::template apply<typename IdentityBegin::item, current_value>::type transformed_identity_equation;
+        typedef typename invert_handle_after_pivot_row<(RowsBegin::size::value - 1)>::template apply<
+            typename RowsBegin::next,
+            typename IdentityBegin::next,
+            new_equation,
+            transformed_identity_equation
+        > next;
+
+        // results
+        // Note that we don't add the pivot row to the
+        // results here, because it needs to propagated up
+        // to the diagonal.
+        typedef typename next::new_matrix new_matrix;
+        typedef typename next::identity_result identity_result;
+        typedef new_equation pivot_row;
+        typedef transformed_identity_equation identity_pivot_row;
+    };
 };
 
+// The one and only non-zero element--at the end
 template<>
-struct solve_impl<true> {
-    template<class T>
+struct invert_strip_leading_zeroes<false, true> {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef typename RowsBegin::item current_row;
+        typedef typename current_row::item current_value;
+        typedef typename divide_equation<(current_row::size::value - 1)>::template apply<typename current_row::next, current_value>::type new_equation;
+        typedef typename divide_equation<(IdentityBegin::item::size::value)>::template apply<typename IdentityBegin::item, current_value>::type transformed_identity_equation;
+
+        // results
+        // Note that we don't add the pivot row to the
+        // results here, because it needs to propagated up
+        // to the diagonal.
+        typedef dimensionless_type identity_result;
+        typedef dimensionless_type new_matrix;
+        typedef new_equation pivot_row;
+        typedef transformed_identity_equation identity_pivot_row;
     };
 };
 
-// check_extra_equations verifies that the
-// after all the variables have been eliminated
-// the remaining equations are all 0=0.
-
-template<class T>
-struct check_extra_equations_func {
-    template<class Begin, int N>
+// One of the initial zeroes
+template<>
+struct invert_strip_leading_zeroes<true, false> {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef inconsistent type;
+        typedef typename RowsBegin::item current_row;
+        typedef typename RowsBegin::next::item next_row;
+        typedef typename invert_strip_leading_zeroes<
+            next_row::item::Numerator == 0,
+            RowsBegin::size::value == 2
+        >::template apply<
+            typename RowsBegin::next,
+            typename IdentityBegin::next
+        > next;
+        typedef typename IdentityBegin::item current_identity_row;
+        // these are propagated up.
+        typedef typename next::pivot_row pivot_row;
+        typedef typename next::identity_pivot_row identity_pivot_row;
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_row::size::value - 1)>::template apply<
+                typename current_row::next,
+                pivot_row,
+                typename current_row::item,
+                static_rational<1>
+            >::type,
+            typename next::new_matrix
+        > new_matrix;
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_identity_row::size::value)>::template apply<
+                current_identity_row,
+                identity_pivot_row,
+                typename current_row::item,
+                static_rational<1>
+            >::type,
+            typename next::identity_result
+        > identity_result;
     };
 };
 
+// the last element, and is zero.
+// Should never happen.
 template<>
-struct check_extra_equations_func<static_rational<0> > {
-    template<class Begin, int N>
-    struct apply {
-        typedef typename check_extra_equations_impl<N - 1>::template apply<typename mpl::next<Begin>::type>::type type;
-    };
+struct invert_strip_leading_zeroes<true, true> {
 };
 
 template<int N>
-struct check_extra_equations_impl {
-    template<class Begin>
+struct invert_handle_after_pivot_row {
+    template<class RowsBegin, class IdentityBegin, class MatrixPivot, class IdentityPivot>
     struct apply {
-        typedef typename check_extra_equations_func<
-            typename mpl::deref<typename mpl::begin<typename mpl::deref<Begin>::type>::type>::type
-        >::template apply<Begin, N>::type type;
+        typedef typename invert_handle_after_pivot_row<N - 1>::template apply<
+            typename RowsBegin::next,
+            typename IdentityBegin::next,
+            MatrixPivot,
+            IdentityPivot
+        > next;
+        typedef typename RowsBegin::item current_row;
+        typedef typename IdentityBegin::item current_identity_row;
+        typedef MatrixPivot pivot_row;
+        typedef IdentityPivot identity_pivot_row;
+
+        // results
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_row::size::value - 1)>::template apply<
+                typename current_row::next,
+                pivot_row,
+                typename current_row::item,
+                static_rational<1>
+            >::type,
+            typename next::new_matrix
+        > new_matrix;
+        typedef list<
+            typename eliminate_from_pair_of_equations_impl<(current_identity_row::size::value)>::template apply<
+                current_identity_row,
+                identity_pivot_row,
+                typename current_row::item,
+                static_rational<1>
+            >::type,
+            typename next::identity_result
+        > identity_result;
     };
 };
 
 template<>
-struct check_extra_equations_impl<0> {
-    template<class Begin>
+struct invert_handle_after_pivot_row<0> {
+    template<class RowsBegin, class IdentityBegin, class MatrixPivot, class IdentityPivot>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type new_matrix;
+        typedef dimensionless_type identity_result;
     };
 };
 
-template<bool is_end>
-struct check_extra_equations;
-
-template<>
-struct check_extra_equations<true> {
-    template<class T>
+template<int N>
+struct invert_impl {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef typename check_extra_equations_impl<mpl::size<T>::value>::template apply<
-            typename mpl::begin<T>::type
+        typedef typename invert_handle_inital_rows<RowsBegin::size::value - N>::template apply<RowsBegin, IdentityBegin> process_column;
+        typedef typename invert_impl<N - 1>::template apply<
+            typename process_column::new_matrix,
+            typename process_column::identity_result
         >::type type;
     };
 };
 
 template<>
-struct check_extra_equations<false> {
-    template<class T>
+struct invert_impl<0> {
+    template<class RowsBegin, class IdentityBegin>
     struct apply {
-        typedef typename mpl::begin<T>::type begin;
-        typedef typename elimination_skip_leading_zeros_impl<
-            boost::is_same<
-                typename mpl::deref<
-                    typename mpl::begin<typename mpl::deref<begin>::type>::type
-                >::type,
-                static_rational<0>
-            >::value,
-            mpl::size<T>::value == 1
-        >::template apply<
-            begin,
-            mpl::size<T>::value,
-            mpl::list0<>
-        >::type type;
+        typedef IdentityBegin type;
     };
 };
 
-template<>
-struct solve_impl<false> {
-    template<class T>
+template<int N>
+struct make_identity {
+    template<int Size>
     struct apply {
-        typedef typename mpl::begin<T>::type begin;
-        typedef typename check_extra_equations<
-            mpl::size<typename mpl::deref<begin>::type>::value == 1
-        >::template apply<
-            T
-        >::type type;
+        typedef list<typename create_row_of_identity<Size - N, Size>::type, typename make_identity<N - 1>::template apply<Size>::type> type;
     };
 };
 
-// solve takes a list of equations and returns the solutions
-// as a vector.  Each equation is interpreted as a sequence
-// of coefficients with the last item being the value e.g.
-// list<1, 2, 3> is 1 * x0 + 2 * x1 = 3
+template<>
+struct make_identity<0> {
+    template<int Size>
+    struct apply {
+        typedef dimensionless_type type;
+    };
+};
 
-template<class T>
-struct solve {
-    typedef typename solve_impl<mpl::size<T>::value == 0>::template apply<T>::type type;
+template<class Matrix>
+struct make_square_and_invert {
+    typedef typename Matrix::item top_row;
+    typedef typename determine_extra_equations<(top_row::size::value), false>::template apply<
+        Matrix,                 // RowsBegin
+        top_row::size::value,   // TotalColumns
+        Matrix                  // Result
+    >::type invertible;
+    typedef typename invert_impl<invertible::size::value>::template apply<
+        invertible,
+        typename make_identity<invertible::size::value>::template apply<invertible::size::value>::type
+    >::type type;
 };
 
+
 // find_base_dimensions takes a list of
 // base_units and returns a sorted list
 // of all the base_dimensions they use.
@@ -412,16 +557,65 @@
 //     return(sort(dimensions, _1 > _2, front_inserter(list<base_dimension>())));
 // }
 
+typedef char set_no;
+struct set_yes { set_no dummy[2]; };
+
+template<class T>
+struct wrap {};
+
+struct set_end {
+    static set_no lookup(...);
+    typedef mpl::long_<0> size;
+};
+
+template<class T, class Next>
+struct set : Next {
+    using Next::lookup;
+    static set_yes lookup(wrap<T>*);
+    typedef T item;
+    typedef Next next;
+    typedef typename mpl::next<typename Next::size>::type size;
+};
+
+template<bool has_key>
+struct set_insert;
+
+template<>
+struct set_insert<true> {
+    template<class Set, class T>
+    struct apply {
+        typedef Set type;
+    };
+};
+
+template<>
+struct set_insert<false> {
+    template<class Set, class T>
+    struct apply {
+        typedef set<T, Set> type;
+    };
+};
+
+template<class Set, class T>
+struct has_key {
+    static const long size = sizeof(Set::lookup((wrap<T>*)0));
+    static const bool value = (size == sizeof(set_yes));
+};
+
 template<int N>
 struct find_base_dimensions_impl_impl {
     template<class Begin, class S>
     struct apply {
-        typedef typename mpl::insert<
-            typename find_base_dimensions_impl_impl<N-1>::template apply<
-                typename mpl::next<Begin>::type,
-                S
-            >::type,
-            typename mpl::deref<Begin>::type::tag_type
+        typedef typename find_base_dimensions_impl_impl<N-1>::template apply<
+            typename Begin::next,
+            S
+        >::type next;
+
+        typedef typename set_insert<
+            (has_key<next, typename Begin::item::tag_type>::value)
+        >::template apply<
+            next,
+            typename Begin::item::tag_type
         >::type type;
     };
 };
@@ -438,9 +632,9 @@
 struct find_base_dimensions_impl {
     template<class Begin>
     struct apply {
-        typedef typename find_base_dimensions_impl_impl<mpl::size<typename mpl::deref<Begin>::type::dimension_type>::value>::template apply<
-            typename mpl::begin<typename mpl::deref<Begin>::type::dimension_type>::type,
-            typename find_base_dimensions_impl<N-1>::template apply<typename mpl::next<Begin>::type>::type
+        typedef typename find_base_dimensions_impl_impl<(Begin::item::dimension_type::size::value)>::template apply<
+            typename Begin::item::dimension_type,
+            typename find_base_dimensions_impl<N-1>::template apply<typename Begin::next>::type
         >::type type;
     };
 };
@@ -449,16 +643,16 @@
 struct find_base_dimensions_impl<0> {
     template<class Begin>
     struct apply {
-        typedef mpl::set0<> type;
+        typedef set_end type;
     };
 };
 
 template<class T>
 struct find_base_dimensions {
-    typedef typename bubble_sort<
+    typedef typename insertion_sort<
         typename find_base_dimensions_impl<
-            mpl::size<T>::value
-        >::template apply<typename mpl::begin<T>::type>::type
+            (T::size::value)
+        >::template apply<T>::type
     >::type type;
 };
 
@@ -480,8 +674,8 @@
 struct calculate_base_dimension_coefficients_func<true> {
     template<class T>
     struct apply {
-        typedef typename mpl::deref<T>::type::value_type type;
-        typedef typename mpl::next<T>::type next;
+        typedef typename T::item::value_type type;
+        typedef typename T::next next;
     };
 };
 
@@ -504,7 +698,7 @@
     struct apply : 
         boost::is_same<
             Dim,
-            typename mpl::deref<Iterator>::type::tag_type
+            typename Iterator::item::tag_type
         > {};
 };
 
@@ -519,19 +713,19 @@
     template<class BaseUnitDimensions,class Dim,class T>
     struct apply {
         typedef typename calculate_base_dimension_coefficients_func<
-            begins_with_dimension<typename mpl::deref<BaseUnitDimensions>::type>::template apply<
+            begins_with_dimension<typename BaseUnitDimensions::item>::template apply<
                 Dim
             >::value
         >::template apply<
-            typename mpl::deref<BaseUnitDimensions>::type
+            typename BaseUnitDimensions::item
         > result;
         typedef typename calculate_base_dimension_coefficients_impl<N-1>::template apply<
-            typename mpl::next<BaseUnitDimensions>::type,
+            typename BaseUnitDimensions::next,
             Dim,
-            typename mpl::push_front<T, typename result::type>::type
+            list<typename result::type, T>
         > next_;
         typedef typename next_::type type;
-        typedef typename mpl::push_front<typename next_::next, typename result::next>::type next;
+        typedef list<typename result::next, typename next_::next> next;
     };
 };
 
@@ -540,87 +734,7 @@
     template<class Begin, class BaseUnitDimensions, class T>
     struct apply {
         typedef T type;
-        typedef mpl::list0<> next;
-    };
-};
-
-// solve_for_base_dimension_impl computes the
-// coefficients of each unit for all the base_dimensions.
-// the inner lists are in reverse order.
-
-template<int N>
-struct get_equations_for_base_dimension_impl {
-    template<class Begin, class Units>
-    struct apply {
-        typedef typename calculate_base_dimension_coefficients_impl<mpl::size<Units>::value>::template apply<
-            typename mpl::begin<Units>::type,
-            typename mpl::deref<Begin>::type,
-            mpl::list0<>
-        > x;
-        typedef typename mpl::push_front<
-            typename get_equations_for_base_dimension_impl<N-1>::template apply<
-                typename mpl::next<Begin>::type,
-                typename x::next
-            >::type,
-            typename x::type
-        >::type type;
-    };
-};
-
-template<>
-struct get_equations_for_base_dimension_impl<0> {
-    template<class Begin, class Units>
-    struct apply {
-        typedef mpl::list0<> type;
-    };
-};
-
-// get_dimension_iterators_impl takes a list of base_units
-// and returns a list of the begin iterators of their
-// dimensions
-
-template<int N>
-struct get_dimension_iterators_impl {
-    template<class Begin>
-    struct apply {
-        typedef typename mpl::push_front<
-            typename get_dimension_iterators_impl<N-1>::template apply<typename mpl::next<Begin>::type>::type,
-            typename mpl::begin<typename mpl::deref<Begin>::type::dimension_type>::type
-        >::type type;
-    };
-};
-
-template<>
-struct get_dimension_iterators_impl<0> {
-    template<class Begin>
-    struct apply {
-        typedef mpl::list0<> type;
-    };
-};
-
-// prepare_equations takes the result of
-// solve_for_base_dimension_impl and an index.
-// it sets the equation at the index equal to
-// one and all the others to zero.  In the process
-// it reverses the inner lists thus yielding
-// a matrix that can be passed to solve.
-
-template<int N>
-struct prepare_equations_impl {
-    template<class Begin, int M>
-    struct apply {
-        typedef typename mpl::push_front<
-            typename prepare_equations_impl<N-1>::template apply<typename mpl::next<Begin>::type, M - 1>::type,
-            typename mpl::reverse<typename mpl::push_front<typename mpl::deref<Begin>::type, static_rational<(M == 0 ? 1 : 0)> >::type>::type
-        >::type type;
-    };
-};
-
-template<>
-struct prepare_equations_impl<0> {
-    template<class Begin, int M>
-    struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type next;
     };
 };
 
@@ -642,10 +756,10 @@
     BOOST_MPL_ASSERT_MSG((N > 0), base_units_are_probably_not_linearly_independent, (void));
     template<class T>
     struct apply {
-        typedef typename mpl::push_front<
-            typename add_zeroes_impl<N-1>::template apply<T>::type,
-            static_rational<0>
-        >::type type;
+        typedef list<
+            static_rational<0>,
+            typename add_zeroes_impl<N-1>::template apply<T>::type
+        > type;
     };
 };
 
@@ -657,205 +771,6 @@
     };
 };
 
-// add_solutions takes a list of equations
-// for the extra dummy units and a list
-// of the values of all the regular units.
-// It find the coefficients of all the dummy
-// units and pushes them onto the begining
-// of the list in reverse order (since the
-// dummy equations are reversed).
-
-template<int N>
-struct add_solutions_impl {
-    template<class Begin, class T, class Solution>
-    struct apply {
-        typedef typename add_solutions_impl<N-1>::template apply<
-            typename mpl::next<Begin>::type,
-            typename mpl::push_front<
-                T,
-                typename substitute_impl<mpl::size<Solution>::value>::template apply<
-                    typename mpl::begin<typename mpl::deref<Begin>::type>::type,
-                    typename mpl::begin<Solution>::type
-                >::type
-            >::type,
-            Solution
-        >::type type;
-    };
-};
-
-template<>
-struct add_solutions_impl<0> {
-    template<class Begin, class T, class Solution>
-    struct apply {
-        typedef T type;
-    };
-};
-
-// normalize_units finds the units corresponding
-// to each base dimension.  The form of the result is
-// a two dimensional list.  list<list<rational> >.
-// each of the inner lists represents a single
-// base dimension.  There may be extra units added
-// to the front of the inner list if there are
-// more base dimensions than base units.  The
-// number such units is returned as a long called
-// extra.  For example list<pound, foot> will yield
-// list<list<0, 0, 1>,list<1, 0, 0>,list<1/2,-1/2,1/2> > meaning
-//
-//   length = 0 * mass + 0 * force + 1 * length
-//   mass   = 1 * mass + 0 * force + 0 * length
-//   time   = 1/2 * mass - 1/2 * force + 1/2 * length
-//
-// Why is there a dummy mass unit?  It isn't
-// possible to represent three base dimensions
-// with only two base units.  So we need some
-// kind of dummy.  Why mass?  Well, a base
-// unit of length doesn't help us since we
-// already have one.  Mass is before time
-// so we use mass.
-
-// S is the solution for this particular base dimension.
-// if the base dimension cannot be represented then
-// solve will return inconsistent hence the two specializations.
-
-template<class S>
-struct normalize_units_func {
-    template<class ReverseEquations, int M, class DimensionIterator, int N, int Extra, int I,class ExtraEquations>
-    struct apply {
-        // first add zeroes for all the extra units that
-        // are not needed.
-        typedef typename add_zeroes_impl<Extra-mpl::size<ExtraEquations>::value>::template apply<S>::type result1;
-        // then find the values for the extra units that /are/ needed.
-        typedef typename add_solutions_impl<mpl::size<ExtraEquations>::value>::template apply<
-            typename mpl::begin<ExtraEquations>::type,
-            result1,
-            S
-        >::type result;
-        // recurse back to the primary loop putting
-        // push_front outside since we wish to maintain
-        // the original ordering of dimensions
-        typedef typename mpl::push_front<
-            typename normalize_units_impl<N-1>::template apply<
-                // The coefficient are still the same
-                // and we don't need to remove any equations
-                ReverseEquations,
-                // increment the number of equations that
-                // need to be skipped when we add another
-                // dummy unit.
-                M+1,
-                typename mpl::next<DimensionIterator>::type,
-                Extra,
-                // increment the number of dimensions we've seen
-                I+1,
-                // pass the equations for the dummy
-                // units on without modification.
-                ExtraEquations
-            >::type,
-            result
-        >::type type;
-    };
-};
-
-// handles the case when this base dimension
-// cannot be represented with the base units
-// and the dummies allready added.
-template<>
-struct normalize_units_func<inconsistent> {
-    template<class ReverseEquations, int M, class DimensionIterator, int N, int Extra, int I, class ExtraEquations>
-    struct apply {
-        // Find the position that needs to be erased. (Since this
-        // equation can always be adjusted by adjusting the
-        // dummy unit we are adding now, independently of
-        // other units, we don't need it anymore.)
-        typedef typename mpl::advance_c<typename mpl::begin<ReverseEquations>::type, M>::type pos;
-        // Continue with the main loop.
-        typedef typename normalize_units_impl<N-1>::template apply<
-            // Remove current_equation
-            typename mpl::erase<
-                ReverseEquations,
-                pos
-            >::type,
-            M,
-            typename mpl::next<DimensionIterator>::type,
-            Extra,
-            // Increment the number of dimensions we've seen
-            I+1,
-            // Add "current_equation == 0" to the list of equations
-            // for the dummy units.  (For all base dimensions
-            // except this the current dimension must sum to
-            // zero.)
-            typename mpl::push_front<
-                ExtraEquations,
-                // Remember it's backwards
-                typename mpl::reverse<
-                    typename mpl::push_front<typename mpl::deref<pos>::type, static_rational<0> >::type
-                >::type
-            >::type
-        > next;
-        // this dimension is (0, ..., 0, 1, 0, ..., 0)
-        typedef typename mpl::push_front<
-            typename add_zeroes_impl<N-1>::template apply<mpl::list0<> >::type,
-            static_rational<1>
-        >::type result1;
-        typedef typename add_zeroes_impl<I>::template apply<result1>::type result;
-        // Push the result onto the list.
-        typedef typename mpl::push_front<typename next::type, result>::type type;
-    };
-};
-
-template<int N>
-struct normalize_units_impl {
-    template<class ReverseEquations, int M, class DimensionIterator, int Extra, int I, class ExtraEquations>
-    struct apply {
-        typedef typename solve<
-            typename prepare_equations_impl<
-                mpl::size<ReverseEquations>::value
-            >::template apply<
-                typename mpl::begin<ReverseEquations>::type,
-                M
-            >::type
-        >::type solution;
-        typedef typename normalize_units_func<solution>::template apply<
-            ReverseEquations,
-            M,
-            DimensionIterator,
-            N,
-            Extra,
-            I,
-            ExtraEquations
-        >::type type;
-    };
-};
-
-template<>
-struct normalize_units_impl<0> {
-    template<class ReverseEquations, int M, class DimensionIterator, int Extra, int I, class ExtraEquations>
-    struct apply {
-        typedef mpl::list0<> type;
-    };
-};
-
-template<class T>
-struct normalize_units {
-    typedef typename find_base_dimensions<T>::type dimensions;
-    typedef typename get_dimension_iterators_impl<mpl::size<T>::value>::template apply<typename mpl::begin<T>::type>::type iterators;
-    typedef typename get_equations_for_base_dimension_impl<
-        mpl::size<dimensions>::value
-    >::template apply<
-        typename mpl::begin<dimensions>::type,
-        iterators
-    >::type reverse_equations;
-    static const long extra = mpl::size<reverse_equations>::value - mpl::size<T>::value;
-    typedef typename normalize_units_impl<mpl::size<reverse_equations>::value>::template apply<
-        reverse_equations,
-        0,
-        typename mpl::begin<dimensions>::type,
-        extra,
-        0,
-        mpl::list0<>
-    >::type type;
-};
-
 // expand_dimensions finds the exponents of
 // a set of dimensions in a dimension_list.
 // the second parameter is assumed to be
@@ -869,12 +784,12 @@
     template<class Begin, class DimensionIterator>
     struct apply {
         typedef typename calculate_base_dimension_coefficients_func<
-            begins_with_dimension<DimensionIterator>::template apply<typename mpl::deref<Begin>::type>::value
+            begins_with_dimension<DimensionIterator>::template apply<typename Begin::item>::value
         >::template apply<DimensionIterator> result;
-        typedef typename mpl::push_front<
-            typename expand_dimensions<N-1>::template apply<typename mpl::next<Begin>::type, typename result::next>::type,
-            typename result::type
-        >::type type;
+        typedef list<
+            typename result::type,
+            typename expand_dimensions<N-1>::template apply<typename Begin::next, typename result::next>::type
+        > type;
     };
 };
 
@@ -882,10 +797,38 @@
 struct expand_dimensions<0> {
     template<class Begin, class DimensionIterator>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type type;
+    };
+};
+
+template<int N>
+struct create_unit_matrix {
+    template<class Begin, class Dimensions>
+    struct apply {
+        typedef typename create_unit_matrix<N - 1>::template apply<typename Begin::next, Dimensions>::type next;
+        typedef list<typename expand_dimensions<Dimensions::size::value>::template apply<Dimensions, typename Begin::item::dimension_type>::type, next> type;
     };
 };
 
+template<>
+struct create_unit_matrix<0> {
+    template<class Begin, class Dimensions>
+    struct apply {
+        typedef dimensionless_type type;
+    };
+};
+
+template<class T>
+struct normalize_units {
+    typedef typename find_base_dimensions<T>::type dimensions;
+    typedef typename create_unit_matrix<(T::size::value)>::template apply<
+        T,
+        dimensions
+    >::type matrix;
+    typedef typename make_square_and_invert<matrix>::type type;
+    static const long extra = (type::size::value) - (T::size::value);
+};
+
 // multiply_add_units computes M x V
 // where M is a matrix and V is a horizontal
 // vector
@@ -896,20 +839,20 @@
 struct multiply_add_units_impl {
     template<class Begin1, class Begin2 ,class X>
     struct apply {
-        typedef typename mpl::push_front<
-            typename multiply_add_units_impl<N-1>::template apply<
-                typename mpl::next<Begin1>::type,
-                typename mpl::next<Begin2>::type,
-                X
-            >::type,
+        typedef list<
             typename mpl::plus<
                 typename mpl::times<
-                    typename mpl::deref<Begin2>::type,
+                    typename Begin2::item,
                     X
                 >::type,
-                typename mpl::deref<Begin1>::type
+                typename Begin1::item
+            >::type,
+            typename multiply_add_units_impl<N-1>::template apply<
+                typename Begin1::next,
+                typename Begin2::next,
+                X
             >::type
-        >::type type;
+        > type;
     };
 };
 
@@ -917,7 +860,7 @@
 struct multiply_add_units_impl<0> {
     template<class Begin1, class Begin2 ,class X>
     struct apply {
-        typedef mpl::list0<> type;
+        typedef dimensionless_type type;
     };
 };
 
@@ -926,16 +869,14 @@
     template<class Begin1, class Begin2>
     struct apply {
         typedef typename multiply_add_units_impl<
-            mpl::size<typename mpl::deref<Begin2>::type>::value
+            (Begin2::item::size::value)
         >::template apply<
-            typename mpl::begin<
-                typename multiply_add_units<N-1>::template apply<
-                    typename mpl::next<Begin1>::type,
-                    typename mpl::next<Begin2>::type
-                >::type
+            typename multiply_add_units<N-1>::template apply<
+                typename Begin1::next,
+                typename Begin2::next
             >::type,
-            typename mpl::begin<typename mpl::deref<Begin2>::type>::type,
-            typename mpl::deref<Begin1>::type
+            typename Begin2::item,
+            typename Begin1::item
         >::type type;
     };
 };
@@ -945,16 +886,14 @@
     template<class Begin1, class Begin2>
     struct apply {
         typedef typename add_zeroes_impl<
-            mpl::size<typename mpl::deref<Begin2>::type>::value
-        >::template apply<mpl::list0<> >::type type1;
+            (Begin2::item::size::value)
+        >::template apply<dimensionless_type>::type type1;
         typedef typename multiply_add_units_impl<
-            mpl::size<typename mpl::deref<Begin2>::type>::value
+            (Begin2::item::size::value)
         >::template apply<
-            typename mpl::begin<
-                type1
-            >::type,
-            typename mpl::begin<typename mpl::deref<Begin2>::type>::type,
-            typename mpl::deref<Begin1>::type
+            type1,
+            typename Begin2::item,
+            typename Begin1::item
         >::type type;
     };
 };
@@ -988,7 +927,7 @@
 struct strip_zeroes_func<static_rational<0> > {
     template<class L, int N>
     struct apply {
-        typedef typename strip_zeroes_impl<N-1>::template apply<typename mpl::pop_front<L>::type>::type type;
+        typedef typename strip_zeroes_impl<N-1>::template apply<typename L::next>::type type;
     };
 };
 
@@ -996,7 +935,7 @@
 struct strip_zeroes_impl {
     template<class T>
     struct apply {
-        typedef typename strip_zeroes_func<typename mpl::front<T>::type>::template apply<T, N>::type type;
+        typedef typename strip_zeroes_func<typename T::item>::template apply<T, N>::type type;
     };
 };
 
@@ -1043,12 +982,12 @@
 struct is_simple_system_impl {
     template<class Begin, class Prev>
     struct apply {
-        typedef is_base_dimension_unit<typename mpl::deref<Begin>::type::dimension_type> test;
+        typedef is_base_dimension_unit<typename Begin::item::dimension_type> test;
         typedef mpl::and_<
             typename test::type,
             mpl::less<Prev, typename test::base_dimension_type>,
             typename is_simple_system_impl<N-1>::template apply<
-                typename mpl::next<Begin>::type,
+                typename Begin::next,
                 typename test::base_dimension_type
             >
         > type;
@@ -1065,14 +1004,14 @@
 
 template<class T>
 struct is_simple_system {
-    typedef typename mpl::begin<T>::type Begin;
-    typedef is_base_dimension_unit<typename mpl::deref<Begin>::type::dimension_type> test;
+    typedef T Begin;
+    typedef is_base_dimension_unit<typename Begin::item::dimension_type> test;
     typedef typename mpl::and_<
         typename test::type,
         typename is_simple_system_impl<
-            mpl::size<T>::value - 1
+            T::size::value - 1
         >::template apply<
-            typename mpl::next<Begin>::type,
+            typename Begin::next::type,
             typename test::base_dimension_type
         >
     >::type type;
@@ -1086,9 +1025,9 @@
 struct calculate_base_unit_exponents_impl<true> {
     template<class T, class Dimensions>
     struct apply {
-        typedef typename expand_dimensions<mpl::size<T>::value>::template apply<
-            typename mpl::begin<typename find_base_dimensions<T>::type>::type,
-            typename mpl::begin<Dimensions>::type
+        typedef typename expand_dimensions<(T::size::value)>::template apply<
+            typename find_base_dimensions<T>::type,
+            Dimensions
         >::type type;
     };
 };
@@ -1104,16 +1043,16 @@
         // e.g. if the arguments are list<pound, foot> and
         // list<mass,time^-2> then this step will
         // yield list<0,1,-2>
-        typedef typename expand_dimensions<mpl::size<typename base_solutions::dimensions>::value>::template apply<
-            typename mpl::begin<typename base_solutions::dimensions>::type,
-            typename mpl::begin<Dimensions>::type
+        typedef typename expand_dimensions<(base_solutions::dimensions::size::value)>::template apply<
+            typename base_solutions::dimensions,
+            Dimensions
         >::type dimensions;
         // take the unit corresponding to each base unit
         // multiply each of its exponents by the exponent
         // of the base_dimension in the result and sum.
-        typedef typename multiply_add_units<mpl::size<dimensions>::value>::template apply<
-            typename mpl::begin<dimensions>::type,
-            typename mpl::begin<typename base_solutions::type>::type
+        typedef typename multiply_add_units<dimensions::size::value>::template apply<
+            dimensions,
+            typename base_solutions::type
         >::type units;
         // Now, verify that the dummy units really
         // cancel out and remove them.

Modified: trunk/boost/units/detail/push_front_if.hpp
==============================================================================
--- trunk/boost/units/detail/push_front_if.hpp	(original)
+++ trunk/boost/units/detail/push_front_if.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -11,12 +11,13 @@
 #ifndef BOOST_UNITS_DETAIL_PUSH_FRONT_IF_HPP
 #define BOOST_UNITS_DETAIL_PUSH_FRONT_IF_HPP
 
-#include <boost/mpl/push_front.hpp>
-
 namespace boost {
 
 namespace units {
 
+template<class T, class Next>
+struct list;
+
 namespace detail {
 
 template<bool>
@@ -26,7 +27,7 @@
 struct push_front_if<true> {
     template<class L, class T>
     struct apply {
-        typedef typename mpl::push_front<L, T>::type type;
+        typedef list<T, L> type;
     };
 };
 

Modified: trunk/boost/units/detail/push_front_or_add.hpp
==============================================================================
--- trunk/boost/units/detail/push_front_or_add.hpp	(original)
+++ trunk/boost/units/detail/push_front_or_add.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -24,6 +24,9 @@
 
 namespace units {
 
+template<class Item, class Next>
+struct list;
+
 namespace detail {
 
 template<class T>
@@ -39,9 +42,9 @@
     template<typename Sequence, typename T>
     struct apply
     {
-        typedef typename mpl::plus<T, typename mpl::front<Sequence>::type>::type item;
+        typedef typename mpl::plus<T, typename Sequence::item>::type item;
         typedef typename push_front_if<!is_empty_dim<item>::value>::template apply<
-            typename mpl::pop_front<Sequence>::type,
+            typename Sequence::next,
             item
         > type;
     };
@@ -53,14 +56,14 @@
     template<typename Sequence, typename T>
     struct apply
     {
-        typedef typename mpl::push_front<Sequence, T>::type type;
+        typedef list<T, Sequence> type;
     };
 };
 
 template<typename Sequence, typename T>
 struct push_front_or_add
 {
-    typedef typename push_front_or_add_impl<boost::is_same<typename T::tag_type, typename mpl::front<Sequence>::type::tag_type>::value>::template apply<
+    typedef typename push_front_or_add_impl<boost::is_same<typename T::tag_type, typename Sequence::item::tag_type>::value>::template apply<
         Sequence,
         T
     >::type type;
@@ -69,7 +72,7 @@
 template<typename T>
 struct push_front_or_add<dimensionless_type, T>
 {
-    typedef typename mpl::push_front<dimensionless_type, T>::type type;
+    typedef list<T, dimensionless_type> type;
 };
 
 } // namespace detail

Modified: trunk/boost/units/detail/sort.hpp
==============================================================================
--- trunk/boost/units/detail/sort.hpp	(original)
+++ trunk/boost/units/detail/sort.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -27,118 +27,77 @@
 
 namespace detail {
 
-template<bool second_is_less>
-struct bubble_sort_conditional_swap;
+template<int N>
+struct insertion_sort_insert;
 
-template<>
-struct bubble_sort_conditional_swap<true>
-{
-    template<class T0, class T1>
-    struct apply
-    {
-        typedef T1 first;
-        typedef T0 second;
-    };
-};
+template<bool is_greater>
+struct insertion_sort_comparison_impl;
 
+// have to recursively add the element to the next sequence.
 template<>
-struct bubble_sort_conditional_swap<false>
-{
-    template<class T0, class T1>
-    struct apply
-    {
-        typedef T0 first;
-        typedef T1 second;
-    };
-};
-
-template<int N>
-struct bubble_sort_pass_impl
-{
-    template<class Begin, class Current>
-    struct apply
-    {
-        typedef typename mpl::deref<Begin>::type val;
-        typedef typename bubble_sort_conditional_swap<mpl::less<val, Current>::value>::template apply<Current, val> pair;
-        typedef typename bubble_sort_pass_impl<N-1>::template apply<typename mpl::next<Begin>::type, typename pair::second> next;
-        typedef typename mpl::push_front<typename next::type, typename pair::first>::type type;
-        enum { value = next::value || mpl::less<val, Current>::value };
+struct insertion_sort_comparison_impl<true> {
+    template<class Begin, int N, class T>
+    struct apply {
+        typedef list<
+            typename Begin::item,
+            typename insertion_sort_insert<N - 1>::template apply<
+                typename Begin::next,
+                T
+            >::type
+        > type;
     };
 };
 
+// prepend the current element
 template<>
-struct bubble_sort_pass_impl<0>
-{
-    template<class Begin, class Current>
-    struct apply
-    {
-        typedef typename mpl::push_front<dimensionless_type, Current>::type type;
-        enum { value = false };
+struct insertion_sort_comparison_impl<false> {
+    template<class Begin, int N, class T>
+    struct apply {
+        typedef list<T, Begin> type;
     };
 };
 
-template<bool>
-struct bubble_sort_impl;
-
-template<>
-struct bubble_sort_impl<true>
-{
-    template<class T>
-    struct apply
-    {
-        typedef typename mpl::begin<T>::type begin;
-        typedef typename bubble_sort_pass_impl<mpl::size<T>::value - 1>::template apply<
-            typename mpl::next<begin>::type,
-            typename mpl::deref<begin>::type
-        > single_pass;
-        typedef typename bubble_sort_impl<(single_pass::value)>::template apply<typename single_pass::type>::type type;
+template<int N>
+struct insertion_sort_insert {
+    template<class Begin, class T>
+    struct apply {
+        typedef typename insertion_sort_comparison_impl<mpl::less<typename Begin::item, T>::value>::template apply<
+            Begin,
+            N,
+            T
+        >::type type;
     };
 };
 
 template<>
-struct bubble_sort_impl<false>
-{
-    template<class T>
-    struct apply
-    {
-        typedef T type;
+struct insertion_sort_insert<0> {
+    template<class Begin, class T>
+    struct apply {
+        typedef list<T, dimensionless_type> type;
     };
 };
 
 template<int N>
-struct bubble_sort_one_or_zero
-{
-    template<class T>
-    struct apply
-    {
-        typedef typename bubble_sort_impl<true>::template apply<T>::type type;
+struct insertion_sort_impl {
+    template<class Begin>
+    struct apply {
+        typedef typename insertion_sort_impl<N - 1>::template apply<typename Begin::next>::type next;
+        typedef typename insertion_sort_insert<(next::size::value)>::template apply<next, typename Begin::item>::type type;
     };
 };
 
 template<>
-struct bubble_sort_one_or_zero<0>
-{
-    template<class T>
-    struct apply
-    {
+struct insertion_sort_impl<0> {
+    template<class Begin>
+    struct apply {
         typedef dimensionless_type type;
     };
 };
 
-template<>
-struct bubble_sort_one_or_zero<1>
-{
-    template<class T>
-    struct apply
-    {
-        typedef typename mpl::push_front<dimensionless_type, typename mpl::front<T>::type>::type type;
-    };
-};
-
 template<class T>
-struct bubble_sort
+struct insertion_sort
 {
-    typedef typename bubble_sort_one_or_zero<mpl::size<T>::value>::template apply<T>::type type;
+    typedef typename insertion_sort_impl<T::size::value>::template apply<T>::type type;
 };
 
 } // namespace detail

Modified: trunk/boost/units/detail/unscale.hpp
==============================================================================
--- trunk/boost/units/detail/unscale.hpp	(original)
+++ trunk/boost/units/detail/unscale.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -141,11 +141,11 @@
     template<class Begin>
     struct apply
     {
-        typedef typename eval_scale_list_impl<N-1>::template apply<typename mpl::next<Begin>::type> next_iteration;
-        typedef typename multiply_typeof_helper<typename next_iteration::type, typename mpl::deref<Begin>::type::value_type>::type type;
+        typedef typename eval_scale_list_impl<N-1>::template apply<typename Begin::next> next_iteration;
+        typedef typename multiply_typeof_helper<typename next_iteration::type, typename Begin::item::value_type>::type type;
         static type value()
         {
-            return(next_iteration::value() * mpl::deref<Begin>::type::value());
+            return(next_iteration::value() * Begin::item::value());
         }
     };
 };
@@ -168,7 +168,7 @@
 
 /// INTERNAL ONLY
 template<class T>
-struct eval_scale_list : detail::eval_scale_list_impl<mpl::size<T>::value>::template apply<typename mpl::begin<T>::type> {};
+struct eval_scale_list : detail::eval_scale_list_impl<T::size::value>::template apply<T> {};
 
 } // namespace units
 

Modified: trunk/boost/units/dimension.hpp
==============================================================================
--- trunk/boost/units/dimension.hpp	(original)
+++ trunk/boost/units/dimension.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -16,8 +16,6 @@
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/mpl/arithmetic.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/size.hpp>
 
 #include <boost/units/static_rational.hpp>
 #include <boost/units/detail/dimension_list.hpp>
@@ -62,8 +60,8 @@
 template<typename DL,typename Ex> 
 struct static_power
 {
-    typedef typename detail::static_power_impl<mpl::size<DL>::value>::template apply<
-        typename mpl::begin<DL>::type,
+    typedef typename detail::static_power_impl<DL::size::value>::template apply<
+        DL,
         Ex
     >::type type;    
 };
@@ -72,8 +70,8 @@
 template<typename DL,typename Rt> 
 struct static_root
 {
-    typedef typename detail::static_root_impl<mpl::size<DL>::value>::template apply<
-        typename mpl::begin<DL>::type,
+    typedef typename detail::static_root_impl<DL::size::value>::template apply<
+        DL,
         Rt
     >::type type;    
 };
@@ -125,9 +123,9 @@
         typedef typename boost::units::detail::merge_dimensions<
             T0,
             typename boost::units::detail::static_inverse_impl<
-                mpl::size<T1>::value
+                T1::size::value
             >::template apply<
-                typename mpl::begin<T1>::type
+                T1
             >::type
         >::type type;
     };

Modified: trunk/boost/units/heterogeneous_system.hpp
==============================================================================
--- trunk/boost/units/heterogeneous_system.hpp	(original)
+++ trunk/boost/units/heterogeneous_system.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -214,12 +214,12 @@
     template<class UnitsBegin, class ExponentsBegin>
     struct apply
     {
-        typedef typename push_front_if<!(is_zero<typename mpl::deref<ExponentsBegin>::type>::value)>::template apply<
+        typedef typename push_front_if<!(is_zero<typename ExponentsBegin::item>::value)>::template apply<
             typename make_heterogeneous_system_impl<N-1>::template apply<
-                typename mpl::next<UnitsBegin>::type,
-                typename mpl::next<ExponentsBegin>::type
+                typename UnitsBegin::next,
+                typename ExponentsBegin::next
             >::type,
-            heterogeneous_system_dim<typename mpl::deref<UnitsBegin>::type, typename mpl::deref<ExponentsBegin>::type>
+            heterogeneous_system_dim<typename UnitsBegin::item, typename ExponentsBegin::item>
         >::type type;
     };
 };
@@ -239,9 +239,9 @@
 {
     typedef typename calculate_base_unit_exponents<typename System::type, Dimensions>::type exponents;
     BOOST_MPL_ASSERT_MSG((!boost::is_same<exponents, inconsistent>::value), the_specified_dimension_is_not_representible_in_the_given_system, (types<Dimensions, System>));
-    typedef typename make_heterogeneous_system_impl<mpl::size<typename System::type>::value>::template apply<
-        typename mpl::begin<typename System::type>::type,
-        typename mpl::begin<exponents>::type
+    typedef typename make_heterogeneous_system_impl<System::type::size::value>::template apply<
+        typename System::type,
+        exponents
     >::type unit_list;
     typedef heterogeneous_system<heterogeneous_system_impl<unit_list, Dimensions, no_scale> > type;
 };
@@ -314,9 +314,9 @@
     {
         typedef typename push_front_or_add<
             typename unscale_heterogeneous_system_impl<N-1>::template apply<
-                typename mpl::next<Begin>::type
+                typename Begin::next
             >::type,
-            typename unscale<typename mpl::deref<Begin>::type>::type
+            typename unscale<typename Begin::item>::type
         >::type type;
     };
 };
@@ -343,9 +343,9 @@
     typedef heterogeneous_system<
         heterogeneous_system_impl<
             typename detail::unscale_heterogeneous_system_impl<
-                mpl::size<typename T::type>::value
+                T::type::size::value
             >::template apply<
-                typename mpl::begin<typename T::type>::type
+                typename T::type
             >::type,
             typename T::dimensions,
             no_scale
@@ -370,9 +370,9 @@
     {
         typedef typename mpl::times<
             typename get_scale_list_of_heterogeneous_system_impl<N-1>::template apply<
-                typename mpl::next<Begin>::type
+                typename Begin::next
             >::type,
-            typename get_scale_list<typename mpl::deref<Begin>::type>::type
+            typename get_scale_list<typename Begin::item>::type
         >::type type;
     };
 };
@@ -395,7 +395,7 @@
 {
     typedef typename mpl::times<
         typename detail::get_scale_list_of_heterogeneous_system_impl<
-            mpl::size<typename T::type>::value
+            T::type::size::value
         >::template apply<typename T::type>::type,
         typename T::scale
     >::type type;

Modified: trunk/boost/units/io.hpp
==============================================================================
--- trunk/boost/units/io.hpp	(original)
+++ trunk/boost/units/io.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -208,10 +208,10 @@
     template<class Begin>
     struct apply
     {
-        typedef typename symbol_string_impl<N-1>::template apply<typename mpl::next<Begin>::type> next;
+        typedef typename symbol_string_impl<N-1>::template apply<typename Begin::next> next;
         static void value(std::string& str)
         {
-            str += base_unit_symbol_string(typename mpl::deref<Begin>::type()) + ' ';
+            str += base_unit_symbol_string(typename Begin::item()) + ' ';
             next::value(str);
         }
     };
@@ -225,7 +225,7 @@
     {
         static void value(std::string& str)
         {
-            str += base_unit_symbol_string(typename mpl::deref<Begin>::type());
+            str += base_unit_symbol_string(typename Begin::item());
         };
     };
 };
@@ -252,8 +252,8 @@
     {
         static void value(std::string& str) 
         {
-            str += mpl::deref<Begin>::type::symbol();
-            scale_symbol_string_impl<N - 1>::template apply<typename mpl::next<Begin>::type>::value(str);
+            str += Begin::item::symbol();
+            scale_symbol_string_impl<N - 1>::template apply<typename Begin::next>::value(str);
         }
     };
 };
@@ -275,10 +275,10 @@
     template<class Begin>
     struct apply
     {
-        typedef typename name_string_impl<N-1>::template apply<typename mpl::next<Begin>::type> next;
+        typedef typename name_string_impl<N-1>::template apply<typename Begin::next> next;
         static void value(std::string& str)
         {
-            str += base_unit_name_string(typename mpl::deref<Begin>::type()) + ' ';
+            str += base_unit_name_string(typename Begin::item()) + ' ';
             next::value(str);
         }
     };
@@ -292,7 +292,7 @@
     {
         static void value(std::string& str)
         {
-            str += base_unit_name_string(typename mpl::deref<Begin>::type());
+            str += base_unit_name_string(typename Begin::item());
         };
     };
 };
@@ -318,8 +318,8 @@
     {
         static void value(std::string& str) 
         {
-            str += mpl::deref<Begin>::type::name();
-            scale_name_string_impl<N - 1>::template apply<typename mpl::next<Begin>::type>::value(str);
+            str += Begin::item::name();
+            scale_name_string_impl<N - 1>::template apply<typename Begin::next>::value(str);
         }
     };
 };
@@ -476,13 +476,11 @@
 struct format_raw_symbol_impl {
     template<class Units>
     void append_units_to(std::string& str) {
-        detail::symbol_string_impl<mpl::size<Units>::value>::template apply<
-            typename mpl::begin<Units>::type>::value(str);
+        detail::symbol_string_impl<Units::size::value>::template apply<Units>::value(str);
     }
     template<class Scale>
     void append_scale_to(std::string& str) {
-        detail::scale_symbol_string_impl<mpl::size<Scale>::value>::template apply<
-            typename mpl::begin<Scale>::type>::value(str);
+        detail::scale_symbol_string_impl<Scale::size::value>::template apply<Scale>::value(str);
     }
     template<class Unit>
     std::string operator()(const Unit& unit) {
@@ -508,13 +506,11 @@
 struct format_raw_name_impl {
     template<class Units>
     void append_units_to(std::string& str) {
-        detail::name_string_impl<mpl::size<Units>::value>::template apply<
-            typename mpl::begin<Units>::type>::value(str);
+        detail::name_string_impl<(Units::size::value)>::template apply<Units>::value(str);
     }
     template<class Scale>
     void append_scale_to(std::string& str) {
-        detail::scale_name_string_impl<mpl::size<Scale>::value>::template apply<
-            typename mpl::begin<Scale>::type>::value(str);
+        detail::scale_name_string_impl<Scale::size::value>::template apply<Scale>::value(str);
     }
     template<class Unit>
     std::string operator()(const Unit& unit) {

Modified: trunk/boost/units/make_system.hpp
==============================================================================
--- trunk/boost/units/make_system.hpp	(original)
+++ trunk/boost/units/make_system.hpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -11,8 +11,6 @@
 #ifndef BOOST_UNITS_MAKE_SYSTEM_HPP
 #define BOOST_UNITS_MAKE_SYSTEM_HPP
 
-#include <boost/mpl/list/list10.hpp>
-
 #include <boost/units/config.hpp>
 #include <boost/units/dimensionless_type.hpp>
 #include <boost/units/homogeneous_system.hpp>
@@ -77,55 +75,55 @@
 template<class T0, class T1>
 struct make_system<T0, T1, na, na, na, na, na, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list2<T0, T1> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, dimensionless_type> > >::type> type;
 };
 
 template<class T0, class T1, class T2>
 struct make_system<T0, T1, T2, na, na, na, na, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list3<T0, T1, T2> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, dimensionless_type> > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3>
 struct make_system<T0, T1, T2, T3, na, na, na, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list4<T0, T1, T2, T3> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, dimensionless_type> > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4>
 struct make_system<T0, T1, T2, T3, T4, na, na, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list5<T0, T1, T2, T3, T4> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, dimensionless_type> > > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4, class T5>
 struct make_system<T0, T1, T2, T3, T4, T5, na, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list6<T0, T1, T2, T3, T4, T5> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, list<T5, dimensionless_type> > > > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 struct make_system<T0, T1, T2, T3, T4, T5, T6, na, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list7<T0, T1, T2, T3, T4, T5, T6> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, list<T5, list<T6, dimensionless_type> > > > > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
 struct make_system<T0, T1, T2, T3, T4, T5, T6, T7, na, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list8<T0, T1, T2, T3, T4, T5, T6, T7> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, list<T5, list<T6, list<T7, dimensionless_type> > > > > > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
 struct make_system<T0, T1, T2, T3, T4, T5, T6, T7, T8, na>
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list9<T0, T1, T2, T3, T4, T5, T6, T7, T8> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, list<T5, list<T6, list<T7, list<T8, dimensionless_type> > > > > > > > > >::type> type;
 };
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
 struct make_system
 {
-    typedef homogeneous_system<typename detail::bubble_sort<mpl::list10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::type> type;
+    typedef homogeneous_system<typename detail::insertion_sort<list<T0, list<T1, list<T2, list<T3, list<T4, list<T5, list<T6, list<T7, list<T8, list<T9, dimensionless_type> > > > > > > > > > >::type> type;
 };
 
 #endif

Modified: trunk/libs/units/example/lambda.cpp
==============================================================================
--- trunk/libs/units/example/lambda.cpp	(original)
+++ trunk/libs/units/example/lambda.cpp	2008-06-23 23:04:49 EDT (Mon, 23 Jun 2008)
@@ -49,6 +49,8 @@
 
 #include <boost/lambda/bind.hpp>
 
+static const double pi = 3.14159265358979323846;
+
 //[lambda_snippet_1
 
 int main(int argc, char **argv) {
@@ -105,7 +107,7 @@
    boost::function<bu::quantity<si::current> (bu::quantity<si::time>) >
        i = iamp
            * bl::bind(static_cast<bu::dimensionless_quantity<si::system, double>::type (*)(const bu::quantity<si::plane_angle>&)>(bu::sin),
-                      2.0 * M_PI * si::radian * f * bl::_1)
+                      2.0 * pi * si::radian * f * bl::_1)
            + i0;
 
    cout << "Oscillating current:" << endl