C:/nobackup/private/physical_svn/trunk/source/Copy of playground.cpp

Go to the documentation of this file.

/* typelist of baseunits */

/* invariants: position<number of baseunits, all positions different */

/* conversion of a quantity between two unitsystems: 
   
   all dimensions with nonzero exponents in source unit 
   system must be present in the target unit system. 

   The conversion factor is the product of all base unit conversions. 
   How to determine these automatically?

*/


#include <boost/mpl/vector.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/map.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/multiplies.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/erase_key.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/mpl/equal.hpp>

// this one is taken from mcs::unit s..
#include "physical/detail/static_rational.hpp"
using mcs::units::static_rational;
using mcs::units::static_multiply;
using mcs::units::static_divide;



/* implement some static_power functionality */
/* please be aware that we can easily get out of the admissible range for integers 
   if we convert (1 km)^3 to (10^6mm)^3. 
   Thus we probably need some other representation: based on primes and exponents!
*/

// absolute value
template<int V> struct static_abs {
   BOOST_STATIC_CONSTANT(int, value= V>=0? V : -V);
};

// invert a rational
template<typename R1> struct static_invert {
   typedef typename static_divide<static_rational<1,1>, R1>::type type;
};

// recursive definition
template<typename R1, int EXP> struct static_power_impl {
   BOOST_STATIC_ASSERT(EXP>0);
   typedef typename static_power_impl<R1, EXP-1>::type part;
   typedef typename static_multiply<part, R1>::type  type;
};   
   
// partial specialisations
template<typename R1> struct static_power_impl<R1, 1> {
   typedef R1 type;
};

template<typename R1> struct static_power_impl<R1, 0> {
   typedef static_rational<1,1> type;
};

// work on sign and invert the rational if necessary
template<typename R1, int EXP> struct static_power {
   BOOST_STATIC_CONSTANT(int, E = static_abs<EXP>::value);
   BOOST_STATIC_ASSERT(E>=0);
   typedef typename static_power_impl<R1, E>::type part;
   typedef typename boost::mpl::if_c< (EXP>0), part, typename static_invert<part>::type>::type type;
};


// this should go to testing..
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, -3>::type, static_rational<1,8> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, -2>::type, static_rational<1,4> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, -1>::type, static_rational<1,2> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, -0>::type, static_rational<1,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, 0>::type, static_rational<1,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, 1>::type, static_rational<2,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, 2>::type, static_rational<4,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<2,1>, 3>::type, static_rational<8,1> >::type::value));

BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, -3>::type, static_rational<8,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, -2>::type, static_rational<4,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, -1>::type, static_rational<2,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, -0>::type, static_rational<1,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, 0>::type, static_rational<1,1> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, 1>::type, static_rational<1,2> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, 2>::type, static_rational<1,4> >::type::value));
BOOST_STATIC_ASSERT(( boost::is_same<static_power< static_rational<1,2>, 3>::type, static_rational<1,8> >::type::value));




namespace old_primes {

   struct yes { BOOST_STATIC_CONSTANT(int, value = 1); };
   
   struct no  { BOOST_STATIC_CONSTANT(int, value = 0); };

   template<int a, int b> struct is_divisible {
      typedef typename boost::mpl::if_c< (a/b)*b==a, yes, no>::type type;
      BOOST_STATIC_CONSTANT( int, value = type::value);
   };

   BOOST_STATIC_ASSERT(( is_divisible<8,1>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,2>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,4>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,8>::type::value ));
   BOOST_STATIC_ASSERT(( !is_divisible<8,16>::type::value ));
   BOOST_STATIC_ASSERT(( !is_divisible<8,3>::type::value ));


   // to compute the prime decomposition of n, recursively loop over all(?) numbers up to n 
   // and build an appropriate typelist...

   template<int n> struct primes;

   template<> struct primes<1> {
      typedef boost::mpl::vector<> type;
   };

   template<> struct primes<2> {
      typedef boost::mpl::vector<boost::mpl::integral_c<int,2> > type;
   };

   template<> struct primes<3> {
      typedef boost::mpl::push_back<primes<2>::type, boost::mpl::integral_c<int,3> >::type type;
   };

   // ???
   
   // declaration
   template<typename n, typename upto> struct prime_decomposition;

   // specialisation for upto::value==1:
   template<typename n> struct prime_decomposition<n, boost::mpl::integral_c<int, 1> >{
      typedef boost::mpl::vector<> list;
      typedef n remainder;
   };


   // implementation for upto::value>1:
   template<typename n, typename upto> struct prime_decomposition {
      typedef boost::mpl::integral_c<int, upto::value-1> upto_m1;
      BOOST_STATIC_ASSERT(( upto_m1::value >= 1));
      
      typedef typename prime_decomposition<n, upto_m1> part_decomposition;
      typedef typename part_decomposition::remainder   part_remainder;

      typedef typename boost::mpl::if_c< is_divisible<part_remainder::value, upto::value>::type::value, 
         typename boost::mpl::push_back<typename part_decomposition::list, boost::mpl::integral_c<int, upto::value> >::type, // that additional integral_c should not be necessary
         typename part_decomposition::list >::type list;

      typedef typename boost::mpl::if_c< is_divisible<part_decomposition::remainder::value, upto::value>::type::value, 
         boost::mpl::integral_c<int, (part_decomposition::remainder::value / upto::value) >,
         typename part_decomposition::remainder >::type remainder;

   };


   // Yeah, it already nearly works (still need a loop instead of the "if":
   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 1> >::list, boost::mpl::vector<> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 1> >::remainder, boost::mpl::integral_c<int, 5> >::type::value ));
   
   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 2> >::list, boost::mpl::vector<> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 2> >::remainder, boost::mpl::integral_c<int, 5> >::type::value ));

   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 3> >::list, boost::mpl::vector<> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 3> >::remainder, boost::mpl::integral_c<int, 5> >::type::value ));
   
   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 4> >::list, boost::mpl::vector<> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 4> >::remainder, boost::mpl::integral_c<int, 5> >::type::value ));

   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 5> >::list, boost::mpl::vector<boost::mpl::integral_c<int, 5> > >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 5>, boost::mpl::integral_c<int, 5> >::remainder, boost::mpl::integral_c<int, 1> >::type::value ));

   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 10>, boost::mpl::integral_c<int, 4> >::list, boost::mpl::vector<boost::mpl::integral_c<int, 2> > >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 10>, boost::mpl::integral_c<int, 4> >::remainder, boost::mpl::integral_c<int, 5> >::type::value ));

   BOOST_STATIC_ASSERT(( boost::mpl::equal<typename prime_decomposition<boost::mpl::integral_c<int, 10>, boost::mpl::integral_c<int, 5> >::list, boost::mpl::vector<boost::mpl::integral_c<int, 2>, boost::mpl::integral_c<int, 5> > >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<typename prime_decomposition<boost::mpl::integral_c<int, 10>, boost::mpl::integral_c<int, 5> >::remainder, boost::mpl::integral_c<int, 1> >::type::value ));

};


namespace primes {

   namespace mpl=boost::mpl;

   struct yes { BOOST_STATIC_CONSTANT(int, value = 1); };
   
   struct no  { BOOST_STATIC_CONSTANT(int, value = 0); };

   template<int a, int b> struct is_divisible {
      typedef typename boost::mpl::if_c< (a/b)*b==a, yes, no>::type type;
      BOOST_STATIC_CONSTANT( int, value = type::value);
   };

   BOOST_STATIC_ASSERT(( is_divisible<8,1>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,2>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,4>::type::value ));
   BOOST_STATIC_ASSERT(( is_divisible<8,8>::type::value ));
   BOOST_STATIC_ASSERT(( !is_divisible<8,16>::type::value ));
   BOOST_STATIC_ASSERT(( !is_divisible<8,3>::type::value ));

/*
   typedef mpl::map<> map_;
   typedef mpl::insert<map_, mpl::pair<mpl::integral_c<int, 5>, mpl::integral_c<int, 1> > >::type map_51;
   
   typedef mpl::insert<map_51, mpl::pair<mpl::integral_c<int, 5>, mpl::integral_c<int, 2> > >::type map_52;

   BOOST_STATIC_ASSERT(( mpl::size<map_51>::type::value == 1 ));
   BOOST_STATIC_ASSERT(( mpl::size<map_52>::type::value == 2 )); // XXXX This is not what I expected it to be!! FIXME!
*/

   template<class Map, class Pair> struct add_pair_impl {
      typedef typename Pair::first key;
      typedef typename Pair::second value;
      BOOST_STATIC_ASSERT(( mpl::has_key<Map, key>::type::value ));
      typedef typename mpl::at<Map, key>::type old_value;
      typedef typename mpl::erase_key<Map, key>::type map_erased;
      typedef typename mpl::insert< map_erased, mpl::pair<key, typename mpl::plus<old_value,value>::type > >::type type;
   };


   template<class Map, class Pair, bool> struct add_pair_dispatch;

   template<class Map, class Pair> struct add_pair_dispatch<Map, Pair, true> {
      typedef typename add_pair_impl<Map, Pair>::type type;
   };

   template<class Map, class Pair> struct add_pair_dispatch<Map, Pair, false> {
      typedef typename mpl::insert< Map, Pair >::type type;
   };

   template<class Map, class Pair> struct add_pair {
      typedef typename Pair::first key;
      BOOST_STATIC_CONSTANT( bool, has_key = (mpl::has_key<Map, key>::value) );
      typedef typename add_pair_dispatch<Map, Pair, has_key>::type type;
   };

   typedef mpl::map<> map_;
   typedef add_pair<map_, mpl::pair<mpl::integral_c<int, 5>, mpl::integral_c<int, 1> > >::type map_51;
   typedef add_pair<map_51, mpl::pair<mpl::integral_c<int, 5>, mpl::integral_c<int, 1> > >::type map_52;

   BOOST_STATIC_ASSERT(( mpl::size<map_>::type::value == 0 ));
   BOOST_STATIC_ASSERT(( mpl::size<map_51>::type::value == 1 ));
   BOOST_STATIC_ASSERT(( mpl::size<map_52>::type::value == 1 ));





   // container that hold the prime+exp map together with the remainder
   template<class Map, class Remainder> struct partial_prime_represenation {
      typedef Map map;
      typedef Remainder remainder;
   };

   // metafunction that takes a container, adds p to the map and divedes the remainder by p
   template<class PrimeDecomp, class p> struct reduce_prime_impl;


   template<class Map, class Remainder, class p> struct reduce_prime_impl<partial_prime_represenation<Map, Remainder>, p> {
      BOOST_STATIC_ASSERT(( is_divisible<Remainder::value, p::value>::type::value ));
      typedef typename boost::mpl::integral_c<int, Remainder::value/p::value>::type remainder;
      //typedef typename boost::mpl::insert<Map, boost::mpl::pair<p,boost::mpl::integral_c<int, 1> > >::type map;
      typedef typename add_pair<Map, mpl::pair<p, mpl::integral_c<int, 1> > >::type map;
      typedef partial_prime_represenation<map, remainder> type;
   };


   // some maps that represent primes+exponents
   typedef mpl::map<> empty_map;
   typedef mpl::map<mpl::pair<mpl::integral_c<int, 2>, mpl::integral_c<int, 1> > > map_2;
   typedef mpl::map<mpl::pair<mpl::integral_c<int, 2>, mpl::integral_c<int, 2> > > map_2_2;
   typedef mpl::map<mpl::pair<mpl::integral_c<int, 3>, mpl::integral_c<int, 1> > > map_3;
   typedef mpl::map<mpl::pair<mpl::integral_c<int, 3>, mpl::integral_c<int, 2> > > map_3_3;
   typedef mpl::map<mpl::pair<mpl::integral_c<int, 2>, mpl::integral_c<int, 1> >, 
                    mpl::pair<mpl::integral_c<int, 3>, mpl::integral_c<int, 1> > > map_2_3;

   BOOST_STATIC_ASSERT(( mpl::size<empty_map>::type::value == 0 ));
   BOOST_STATIC_ASSERT(( mpl::size<map_2>::type::value == 1 ));


   // multiply some numbers:
   using mpl::placeholders::_;
   using mpl::placeholders::_1;
   using mpl::placeholders::_2;
   typedef mpl::vector<mpl::integral_c<int,2>, mpl::integral_c<int,3>, mpl::integral_c<int,5> > prime_list_2_3_5;
   typedef mpl::fold<prime_list_2_3_5, mpl::integral_c<int, 1>, mpl::multiplies<_,_> >::type product_2_3_5;
   BOOST_STATIC_ASSERT(( product_2_3_5::value == 2*3*5 ));

   template<class n, class k> struct power_impl {
      typedef mpl::integral_c<int, 1> one;
      typedef typename mpl::multiplies< typename power_impl<n, typename mpl::minus<k,one>::type >::type, n>::type type;
   };

   template<class n> struct power_impl<n, mpl::integral_c<int, 1> > {
      typedef n type;
   };

   template<class n> struct power_impl<n, mpl::integral_c<int, 0> > {
      typedef mpl::integral_c<int, 1> type;
   };

   // accepts classes, gives class
   template<class n, class k> struct static_power {
      typedef typename power_impl<n, k>::type type;
   };

   // accepts ints, gives int
   template<int n, int k> struct int_power {
      typedef typename power_impl<mpl::integral_c<int, n>, mpl::integral_c<int, k> >::type type;
      BOOST_STATIC_CONSTANT(int, value = type::value);
   };

   // accepts pair of classes, gives class
   template<class pair> struct pair_power {
      typedef typename power_impl<typename pair::first, typename pair::second>::type type;
   };

   BOOST_STATIC_ASSERT(( int_power<1,1>::value == 1 ));
   BOOST_STATIC_ASSERT(( int_power<2,1>::value == 2 ));
   BOOST_STATIC_ASSERT(( int_power<2,2>::value == 4 ));
   BOOST_STATIC_ASSERT(( int_power<2,3>::value == 8 ));


   template<class V> struct static_abs;
   template<int k> struct static_abs<mpl::integral_c<int, k> > {
      typedef typename mpl::if_c< (k>0), mpl::integral_c<int, k>, mpl::integral_c<int, -k> >::type type;
   };

   
   template<class n, class k> struct rational_power {
      typedef mpl::integral_c<int, 1> one;
      typedef typename static_abs<k>::type exp;
      typedef typename power_impl<n, exp>::type part;
      typedef typename mpl::if_c< (k::value>=0), static_rational<part::value, one::value>, static_rational<one::value, part::value> >::type type;
   };

   // product of primes+exp
   typedef mpl::pair<mpl::integral_c<int, 2>, mpl::integral_c<int, 3> > pair_2_3;
   BOOST_STATIC_ASSERT(( pair_power<pair_2_3>::type::value == 8 ));

   // transform cannot produce vectors from maps...
   typedef mpl::vector<mpl::pair<mpl::integral_c<int, 2>, mpl::integral_c<int, 1> >, 
                 mpl::pair<mpl::integral_c<int, 3>, mpl::integral_c<int, 1> > > vec_map_2_3;
   // a vector of powers
   typedef mpl::transform< vec_map_2_3, pair_power<_> >::type vec_map_2_3_powers;
   typedef mpl::fold<vec_map_2_3_powers, mpl::integral_c<int, 1>, mpl::multiplies<_,_> >::type vec_map_2_3_total;
   BOOST_STATIC_ASSERT(( vec_map_2_3_total::value == 6 ));

   // However, what about starting with a mpl::map? 
   typedef mpl::fold<map_2_3, mpl::integral_c<int, 1>, mpl::multiplies<_1, pair_power<_2> > >::type vec_from_map_2_3_product;
   BOOST_STATIC_ASSERT(( vec_from_map_2_3_product::value == 6 ));

   // and now put this into some metafunction:
   template<class Map> struct static_map_multiply {
      typedef typename mpl::fold<Map, mpl::integral_c<int, 1>, mpl::multiplies<_1, pair_power<_2> > >::type type;
   };
   BOOST_STATIC_ASSERT(( static_map_multiply<map_2>::type::value == 2 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<map_2_2>::type::value == 4 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<map_3>::type::value == 3 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<map_3_3>::type::value == 9 ));

   BOOST_STATIC_ASSERT(( static_map_multiply<map_>::type::value == 1 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<map_51>::type::value == 5 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<map_52>::type::value == 25 ));


   // forward declaration
   template<class PrimeDecomp, class p> struct reduce_prime;

   template<class PrimeDecomp, class p, bool divisible> struct reduce_prime_dispatch;
   
   template<class PrimeDecomp, class p> struct reduce_prime_dispatch<PrimeDecomp, p, true> {
      typedef typename reduce_prime_impl<PrimeDecomp, p>::type reduced;
      typedef typename reduce_prime<reduced, p>::type type;
   };

   template<class PrimeDecomp, class p> struct reduce_prime_dispatch<PrimeDecomp, p, false> {
      typedef PrimeDecomp type;
   };



   // metafunction that takes a container, adds p to the map and divedes the remainder by p as often as possible
   template<class PrimeDecomp, class p> struct reduce_prime {
      typedef typename PrimeDecomp::remainder Remainder;
      typedef typename reduce_prime_dispatch<PrimeDecomp, p, is_divisible<Remainder::value, p::value>::type::value>::type type;
   };


   template <class n> struct initial_decomp {
      BOOST_STATIC_ASSERT(( n::value >= 1 ));
      typedef typename partial_prime_represenation<mpl::map<>, n> type;
   };

   typedef initial_decomp<mpl::integral_c<int, 25> >::type init_decomp_25;
   BOOST_STATIC_ASSERT(( init_decomp_25::remainder::type::value == 25 )); 
   BOOST_STATIC_ASSERT(( mpl::size<init_decomp_25::map>::type::value == 0 )); 
   BOOST_STATIC_ASSERT(( static_map_multiply<init_decomp_25::map>::type::value == 1 )); 


   typedef reduce_prime<init_decomp_25, mpl::integral_c<int, 5> >::type reduced_25;

   BOOST_STATIC_ASSERT(( reduced_25::remainder::type::value == 1 )); 
   BOOST_STATIC_ASSERT(( mpl::size<reduced_25::map>::type::value == 1 )); 
   BOOST_STATIC_ASSERT(( static_map_multiply<reduced_25::map>::type::value == 25 )); 


   typedef initial_decomp<mpl::integral_c<int, 50> >::type init_decomp_50;
   BOOST_STATIC_ASSERT(( init_decomp_50::remainder::type::value == 50 )); 
   BOOST_STATIC_ASSERT(( mpl::size<init_decomp_50::map>::type::value == 0 )); 
   BOOST_STATIC_ASSERT(( static_map_multiply<init_decomp_50::map>::type::value == 1 )); 

   typedef reduce_prime<init_decomp_50, mpl::integral_c<int, 5> >::type reduced_50_5;
   BOOST_STATIC_ASSERT(( reduced_50_5::remainder::type::value == 2 )); 
   BOOST_STATIC_ASSERT(( mpl::size<reduced_50_5::map>::type::value == 1 )); 
   BOOST_STATIC_ASSERT(( static_map_multiply<reduced_50_5::map>::type::value == 25 )); 

   typedef reduce_prime<reduced_50_5, mpl::integral_c<int, 2> >::type reduced_50_5_2;
   BOOST_STATIC_ASSERT(( reduced_50_5_2::remainder::type::value == 1 )); 
   BOOST_STATIC_ASSERT(( mpl::size<reduced_50_5_2::map>::type::value == 2 )); 
   BOOST_STATIC_ASSERT(( static_map_multiply<reduced_50_5_2::map>::type::value == 50 )); 



   // n is integral class type, returns a decomposition
   template<typename n, typename upto> struct prime_decomposition {
      typedef boost::mpl::integral_c<int, upto::value-1> upto_m1;
      BOOST_STATIC_ASSERT(( upto_m1::value >= 1));
      

      typedef typename prime_decomposition<n, upto_m1>::type part_decomposition;
      typedef typename reduce_prime<part_decomposition, upto>::type type;
   };


   // n is integral class type, returns a decomposition
   template<typename n> struct prime_decomposition<n, mpl::integral_c<int, 1> > {
      typedef typename initial_decomp<n>::type type;
   };

   // n is integral class type, returns a map of primes & exponents
   template<typename n> struct primes {
      typedef typename prime_decomposition<n, n>::type decomposition;
      typedef typename decomposition::map type;
   };


   // 10 = 2^1 * 5^1
   typedef primes<mpl::integral_c<int, 10> >::type primes_10;
   BOOST_STATIC_ASSERT(( mpl::size<primes_10>::type::value == 2 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<primes_10>::type::value == 10 )); 

   // 100 = 2^2 * 5^2
   typedef primes<mpl::integral_c<int, 100> >::type primes_100;
   BOOST_STATIC_ASSERT(( mpl::size<primes_100>::type::value == 2 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<primes_100>::type::value == 100 )); 


#if 1
   // internal compiler error somewhere above 430 , obviously memory overflow.
   // 1000 = 2^3 * 5^3
   typedef primes<mpl::integral_c<int, 430> >::type primes_1000;
   //BOOST_STATIC_ASSERT(( mpl::size<primes_1000>::type::value == 2 ));
   BOOST_STATIC_ASSERT(( static_map_multiply<primes_1000>::type::value == 430 )); 
#endif


#if 0

   typedef primes<1>::type primes_1;
   typedef primes<2>::type primes_2;
//   typedef primes<3>::type primes_3;
//   typedef primes<4>::type primes_4;

   // primes_1 = { };
   BOOST_STATIC_ASSERT(( boost::mpl::size<primes_1>::type::value == 0 ));

   // primes_2 = { 2^1 };
   //BOOST_STATIC_ASSERT(( boost::mpl::size<primes_2>::type::value == 1 ));



   //BOOST_STATIC_ASSERT(( prime_decomposition<boost::mpl::integral_c<int, 1>, boost::mpl::integral_c<int, 1> >::type::remainder ));
   //BOOST_STATIC_ASSERT(( prime_decomposition<boost::mpl::integral_c<int, 1>, boost::mpl::integral_c<int, 1> >::type::remainder ));
#endif
}

namespace newprimes {
   // primes from AT&T:
   //2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271
};
namespace blub {


   // traits class, may be specialized for other basedimensions

   template <class UnitSystem, class BaseDimension>
   struct position {
      typedef typename boost::mpl::find<typename UnitSystem::base_dimensions, BaseDimension>::type iterator;
      BOOST_STATIC_CONSTANT(int, value = iterator::pos::value);
   };

   template<class UnitSystem, class dimension, class unit>
   struct extended_unit_system {
      struct extended {
      typedef extended unitsystem;
      typedef typename boost::mpl::push_back<typename UnitSystem::base_dimensions, dimension>::type base_dimensions;
      typedef typename boost::mpl::push_back<typename UnitSystem::base_units, unit>::type base_units;

      BOOST_STATIC_ASSERT(boost::mpl::size<typename UnitSystem::base_dimensions>::value == boost::mpl::size<typename UnitSystem::base_units>::value);
      BOOST_STATIC_ASSERT(boost::mpl::size<base_dimensions>::value == boost::mpl::size<typename UnitSystem::base_dimensions>::value+1);
      BOOST_STATIC_ASSERT(boost::mpl::size<base_units>::value == boost::mpl::size<typename UnitSystem::base_units>::value+1);
      BOOST_STATIC_ASSERT(boost::mpl::size<base_dimensions>::value == boost::mpl::size<base_units>::value);

      BOOST_STATIC_CONSTANT(int, number_baseunits = boost::mpl::size<base_dimensions>::value);
      };
      typedef extended type;
   };


   // general template declaration, only some specialisations are defined
   template<class unit1, class unit2> struct static_conversion_factor;

   // as a specialisation, the conversion to the very same unit has always conversion factor 1.
   template<class unit1> struct static_conversion_factor<unit1, unit1> { 
      typedef typename static_rational<1,1>::type type; 
   };



   template<class source_UnitSystem, class target_UnitSystem, int source_position>
   struct convert_baseunit_to_other_unit_system {
      
      // what dimension does this position represent?
      typedef typename boost::mpl::at<typename source_UnitSystem::base_dimensions, boost::mpl::int_<source_position> >::type BaseDimension;

      // what position is this very same BaseDimension in the target unit system?
      typedef typename boost::mpl::find<typename target_UnitSystem::base_dimensions, BaseDimension>::type target_iterator;
      BOOST_STATIC_CONSTANT(int, target_position = target_iterator::pos::value);

      // what is the unit used in source unit system
      typedef typename boost::mpl::at<typename source_UnitSystem::base_units, boost::mpl::int_<source_position> >::type source_unit;

      // what is the unit used in target unit system
      typedef typename boost::mpl::at<typename target_UnitSystem::base_units, boost::mpl::int_<target_position> >::type target_unit;
       
      typedef typename static_conversion_factor<source_unit, target_unit>::type conversion_factor;
   };




   // some dimension tags
   struct length              {};
   struct mass                {};
   struct time                {};
   struct electric_current    {};
   struct temperature         {};
   struct amount_of_substance {};
   struct luminous_intensity  {};


   // some unit tags
   struct meter {};
   struct kilogram {};
   struct second {};
   struct ampere {};
   struct kelvin {};
   struct mol {};
   struct candela {};

   struct centimeter {};
   struct gram {};


   template<> struct static_conversion_factor<meter, centimeter> { typedef static_rational<100,1>::type type; };
   template<> struct static_conversion_factor<centimeter, meter> { typedef static_rational<1,100>::type type; };

   template<> struct static_conversion_factor<kilogram, gram> { typedef static_rational<1000,1>::type type; };
   template<> struct static_conversion_factor<gram, kilogram> { typedef static_rational<1000,1>::type type; };



   // full SI set, this should be the default unit system
   struct SI {
      typedef SI unitsystem;
      typedef boost::mpl::vector<length, mass, time, electric_current, temperature, amount_of_substance, luminous_intensity> base_dimensions;
      typedef boost::mpl::vector<meter, kilogram, second, ampere, kelvin, mol, candela> base_units;

      BOOST_STATIC_ASSERT(boost::mpl::size<base_dimensions>::value == boost::mpl::size<base_units>::value);
      BOOST_STATIC_CONSTANT(int, number_baseunits = boost::mpl::size<base_dimensions>::value);
   };

   /* ******* some other unit systems ********* */

   // meter - kilogram - second
   struct MKS {
      typedef MKS unitsystem;
      typedef boost::mpl::vector<length, mass, time> base_dimensions;
      typedef boost::mpl::vector<meter, kilogram, second> base_units;

      BOOST_STATIC_ASSERT(boost::mpl::size<base_dimensions>::value == boost::mpl::size<base_units>::value);
      BOOST_STATIC_CONSTANT(int, number_baseunits = boost::mpl::size<base_dimensions>::value);
   };



   // centimeter - kilogram - second
   // same base dimensions as MKS, but other numerical (internal) representation, all quantities are convertible
   struct CGS {
      typedef CGS unitsystem;
      typedef boost::mpl::vector<length, mass, time> base_dimensions;
      typedef boost::mpl::vector<centimeter, gram, second> base_units;

      BOOST_STATIC_ASSERT(boost::mpl::size<base_dimensions>::value == boost::mpl::size<base_units>::value);
      BOOST_STATIC_CONSTANT(int, number_baseunits = boost::mpl::size<base_dimensions>::value);
   };



   // this should go to unit tests...  
   BOOST_STATIC_ASSERT((convert_baseunit_to_other_unit_system<MKS, CGS, 0>::target_position == 0));
   BOOST_STATIC_ASSERT((convert_baseunit_to_other_unit_system<MKS, CGS, 1>::target_position == 1));
   BOOST_STATIC_ASSERT((convert_baseunit_to_other_unit_system<MKS, CGS, 2>::target_position == 2));

   BOOST_STATIC_ASSERT(( boost::is_same<convert_baseunit_to_other_unit_system<MKS, CGS, 0>::conversion_factor, static_rational<100,1> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<convert_baseunit_to_other_unit_system<MKS, CGS, 1>::conversion_factor, static_rational<1000,1> >::type::value ));
   BOOST_STATIC_ASSERT(( boost::is_same<convert_baseunit_to_other_unit_system<MKS, CGS, 2>::conversion_factor, static_rational<1,1> >::type::value ));

   BOOST_STATIC_ASSERT(( ! boost::is_same<convert_baseunit_to_other_unit_system<MKS, CGS, 0>::conversion_factor, static_rational<1,1> >::type::value ));


   // some further base dimensions
   struct customer_satisfaction {}; // unit = subjective assessment: 1..10
   struct subjective {};

   struct european_currency {};     // unit = EUR, euro_cent;
   struct us_currency {};           // unit = USD, us_cent;


   // SI with customer satisfaction as additional base dimension, some quantities are convertible
   typedef extended_unit_system<SI, customer_satisfaction, subjective>::type extended_SI;


   static const int meter_pos1 = position<SI, length>::value;
   static const int meter_pos2 = position<extended_SI, length>::value;


   BOOST_STATIC_ASSERT( meter_pos1 == meter_pos2 );


   /* ******************************************************************************** */

};

---

hosted on