Unit.h

Go to the documentation of this file.

/* Unit is an abstract base class for units according to the SI, see
   Mills et al., 1993 */

/* Copyright (C) 2002, 2003, Bernd Speiser */
/* This file is part of Quantity.

Quantity is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

Quantity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
  
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

/* a Unit has a symbol and a name, as defined by Mills et al., 1993 */
/* symbol and/or name of a Unit is/are retrieved by the corresponding
   functions as a C++ style string */
/* a Unit can be a SI unit; if not, its use is not recommended;
   this property can be tested by is_SI */
/* to some Units a prefix can be attached; these are in particular 
   the SI base units, the SI derived units with special names (except
   the degree Celsius), some other derived SI units and some of the
   `units in use together with the SI' */ 
/* prefixing is done by adding a private data member UnitPrefix * to 
   the class */
/* Units are often used in close relation to Quantities 
   if several Units are valid for a given Quantity, conversion functions
   are provided;
   one of the appropriate Units is defined as `standard' Unit; 
   the standard unit must correspond to a (combination of) SI unit(s);
   the standardize_function converts the argument value (given in Unit)
   into the standard Unit;
   the destandardize_function converts the argument value (which is 
   assumed to be in the standard Unit) into Unit;
   the conversion functions for the standard Unit return the argument 
   value itself; */
/* a conversion function (?) can be exact or approximate; this property 
   can be tested by is_exact; exact in this context means that it does
   not depend on experimentally determined constants or other 
   variables */
/* copy returns a pointer to a new Unit object of the same type as 
   this function was invoked from */

#ifndef _Unit_h
#define _Unit_h

#include <vector>
#include <string>

#include "Quantity/UnitPrefix.h"

#include "NullType.h"
#include "EmptyType.h"
#include "TypeManip.h"
#include "Typelist.h"

#include "TemplateTools.h"
#include "Conversion.h"


namespace Units {

//
//  Helper classes and structs which check that units are derived
//  from certain base classes 
//


template<bool> 
  struct UnitError;


template<> 
  struct UnitError<false> 
    { 

      typedef UnitError<false> RET;
    };

 

template<class BU, class U>
  struct CheckUnit
  {

    typedef typename
      BSUtilities::IF<Loki::SuperSubclass<BU, U>::value, 
                    UnitError<false>, UnitError<true> >::RET::RET Check;
  };


template<class BU, class U>
  struct CheckUnits
  {
    private: 
      typedef typename CheckUnit<BU, typename U::Head>::Check UnitCheck;

    public: 
      typedef typename CheckUnits<BU, typename U::Tail>::Checked 
                                                                Checked;
  };


template<class BU>
  struct CheckUnits<BU, Loki::NullType>
  {
    typedef Loki::EmptyType Checked;
  };

//
//  the Units and Unit base class templates
//

class Units
  {
    public:

      static std::string version (void)
        {static const std::string v_string ("Units version 1.0");
                                                       return v_string;}

  };


template<class GT, class ST = double> class Unit : public Units
  {
    public:

      virtual const std::string name (void) const = 0;


      virtual const std::string symbol (void) const = 0;


      virtual ST standard (const ST &) const = 0;


      virtual ST reverse (const ST &) const = 0;


      virtual bool is_SI (void) const = 0;


      virtual bool is_exact (void) const = 0;
  };

//
//  the NonPrefixable units
//


template<class GT, class U, class ST = double> 
  class NonPrefixable : public Unit<GT, ST>
  {
    private:
      static const bool SI;

      static const bool Exact;


      static const std::string Namestring;


      static const std::string Symbolstring;

    public:

      static bool Is_SI (void) {return SI;}


      bool is_SI (void) const {return Is_SI ();}


      static bool Is_exact (void) {return Exact;}


      bool is_exact (void) const {return Is_exact ();}


      static const ST StandardRatio;


      static ST standardRatio (void) {return StandardRatio;}


      static ST Standard (const ST &value) 
                                         {return value * StandardRatio;}


      ST standard (const ST &value) const {return Standard (value);}


      static ST Reverse (const ST &value)
                                         {return value / StandardRatio;}


      ST reverse (const ST &value) const {return Reverse (value);}

/*  direct static access to be used if type of unit is known at 
    compile time; returns the namestring;
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static std::string Name (void) {return Namestring;}


      const std::string name (void) const {return Name ();}

/*  direct static access to be used if type of unit is known at 
    compile time; 
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static std::string Symbol (void) {return Symbolstring;}


      const std::string symbol (void) const {return Symbol ();}

  };

//
//  the Prefixable and Prefixed units
//

// forward declaration
template<class GT, class U, class ST = double> class Prefixable;


template<class PU, class P = No> class Prefixed;


template<class GT, class U, class P, class ST> 
  class Prefixed<Prefixable<GT, U, ST>, P> 
                                         : public Prefixable<GT, U, ST>
  {
    public:

      static ST Standard (const ST &value) 
        {return ST(Prefixable<GT, U, ST>::StandardRatio
                                                  * value * P::factor);}

      ST standard (const ST &value) const {return Standard (value);}


      static ST standardRatio (void) 
              {return Prefixable<GT, U, ST>::StandardRatio * P::factor;}


      static ST Reverse (const ST &value) 
        {return ST(value / (Prefixable<GT, U, ST>::StandardRatio *
                                                           P::factor));}


      ST reverse (const ST &value) const {return Reverse (value);}

/*  direct static access to be used if type of unit is known at 
    compile time; 
    get name from prefix and prepend to basename which is inherited
    from Prefixable<GT, U, ST>;
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static std::string Name (void) {return P::Name + Basename;}


      const std::string name (void) const {return Name ();}

/*  direct static access to be used if type of unit is known at 
    compile time; 
    get symbol from prefix and prepend to basesymbol which is inherited
    from Prefixable<GT, U, ST>
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static std::string Symbol (void) {return P::Symbol + Basesymbol;}


      const std::string symbol (void) const {return Symbol ();}
  };


template<class GT, class U, class ST> class Prefixable 
                                                   : public Unit<GT, ST>
  {
    private:

      static const bool SI;


      static const bool Exact;

    public:
      typedef Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Yotta>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Zetta>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Exa>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Peta>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Tera>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Giga>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Mega>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Kilo>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Hecto>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Deca>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, No>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Deci>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Centi>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Milli>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Micro>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Nano>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Pico>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Femto>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Atto>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Zepto>, 
              Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, Yocto>, 
              Loki::NullType> > > > > > > > > > > > > > > > > > > > > 
                                                                  Units;


      static bool Is_SI (void) {return SI;}


      bool is_SI (void) const {return Is_SI ();}


      static bool Is_exact (void) {return Exact;}


      bool is_exact (void) const {return Is_exact ();}


      static const ST StandardRatio;


      static ST standardRatio (void) {return StandardRatio;}

    protected:
/*  direct static access to be used if type of unit is known at 
    compile time 
*/
      static const std::string Basename;

/*  direct static access to be used if type of unit is known at 
    compile time 
*/
      static const std::string Basesymbol;


      static ST Standard (const ST &value) 
                                         {return value * StandardRatio;}


      ST standard (const ST &value) const {return Standard (value);}


      static ST Reverse (const ST &value) 
                                         {return value / StandardRatio;}


      ST reverse (const ST &value) const {return Reverse (value);}

  };

//
//  the Compound and Composed units with helper classes and structs
//  CompoundElement, CheckBoolProperty
//


template<class GT, class UE, class ST = double> class Compound;


template<class BC, class EL> class Composed;


template<class GT, class U, class R, class ST = double> 
                                                struct CompoundElement;


template<class GT, class GT1, class U, class Tail, long N, long D, 
                                                               class ST>
  struct CompoundElement<GT, 
    Loki::Typelist<NonPrefixable<GT1, U, ST>, Tail>, 
                                        BSUtilities::Rational<N, D>, ST>
  {
    private:
      typedef typename CheckUnits<Unit<GT1, ST>, 
        Loki::Typelist<NonPrefixable<GT1, U, ST>, Tail> >::Checked 
                                                                Checked;

    public:
      typedef Loki::Typelist<NonPrefixable<GT1, U, ST>, Tail> Units;
      typedef BSUtilities::Rational<N, D> Power;
  };

template<class GT, class GT1, class U, class P, class Tail, 
                                               long N, long D, class ST>
  struct CompoundElement<GT, 
    Loki::Typelist<Prefixed<Prefixable<GT1, U, ST>, P>, Tail>, 
                                        BSUtilities::Rational<N, D>, ST>
  {
    private:
      typedef typename CheckUnits<Unit<GT1, ST>, 
            Loki::Typelist<Prefixed<Prefixable<GT1, U, ST>, P>, Tail> >
                                                      ::Checked Checked;

    public:
      typedef Loki::Typelist<Prefixed<Prefixable<GT1, U, ST>, P>, Tail>
                                                                  Units;
      typedef BSUtilities::Rational<N, D> Power;
  };

template<class GT, class GT1, class U, class EL, class Tail, 
                                               long N, long D, class ST>
  struct CompoundElement<GT, 
    Loki::Typelist<Composed<Compound<GT1, U, ST>, EL>, Tail>, 
                                        BSUtilities::Rational<N, D>, ST>
  {
    private:
      typedef typename CheckUnits<Unit<GT1, ST>, 
        Loki::Typelist<Composed<Compound<GT1, U, ST>, EL>, Tail> >
                                                      ::Checked Checked;

    public:
      typedef Loki::Typelist<Composed<Compound<GT1, U, ST>, EL>, Tail> 
                                                                  Units;
      typedef BSUtilities::Rational<N, D> Power;
  };


template<class U> struct CheckBoolProperty;


template<class GT, class U, class Tail, class ST>
  struct 
      CheckBoolProperty<Loki::Typelist<NonPrefixable<GT, U, ST>, Tail> >
  {
    static bool is_SI (void) 
      {return ((NonPrefixable<GT, U, ST>::Is_SI ()
                        && CheckBoolProperty<Tail>::is_SI ()) ? 1 : 0);}
    static bool is_exact (void) 
      {return ((NonPrefixable<GT, U, ST>::Is_exact () 
                     && CheckBoolProperty<Tail>::is_exact ()) ? 1 : 0);}
  };
  

template<class GT, class U, class P, class Tail, class ST>
  struct 
    CheckBoolProperty<Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, P>,
                                                                 Tail> >
  {
    static bool is_SI (void) 
      {return ((Prefixable<GT, U, ST>::Is_SI () 
                       && CheckBoolProperty<Tail>::is_SI ()) ? 1 : 0);}
    static bool is_exact (void) 
      {return ((Prefixable<GT, U, ST>::Is_exact () 
                     && CheckBoolProperty<Tail>::is_exact ()) ? 1 : 0);}
  };


template<class GT, class EL, class UL, class Tail, class ST>
  struct 
    CheckBoolProperty<Loki::Typelist<Composed<Compound<GT, EL, ST>, UL>,
                                                                 Tail> >
  {
    static bool is_SI (void) 
      {return ((Composed<Compound<GT, EL, ST>, UL>::Is_SI () 
                       && CheckBoolProperty<Tail>::is_SI ()) ? 1 : 0);}
    static bool is_exact (void) 
      {return ((Composed<Compound<GT, EL, ST>, UL>::Is_exact () 
                     && CheckBoolProperty<Tail>::is_exact ()) ? 1 : 0);}
  };

template<>
  struct CheckBoolProperty<Loki::NullType>
  {
    static bool is_SI (void) {return true;}
    static bool is_exact (void) {return true;}
  };


template<class UL, class UR, class ST = double> class ComposedStandard;


template<class U, class UTail, long N, long D, class RTail, class ST>
  class ComposedStandard<Loki::Typelist<U, UTail>, 
                 Loki::Typelist<BSUtilities::Rational<N, D>, RTail>, ST>
  {
    public:
      static ST StandardRatio (void)
        {return std::pow(U::standardRatio (),
             static_cast<double>(N)/static_cast<double>(D)) *
                  ComposedStandard<UTail, RTail, ST>::StandardRatio ();}
  };


template<class U, long N, long D, class ST>
  class ComposedStandard<Loki::Typelist<U, Loki::NullType>, 
        Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType>, ST>
  {
    public:
      static ST StandardRatio (void)
        {return std::pow(U::standardRatio (),
                        static_cast<double>(N)/static_cast<double>(D));}
  };


template<class Ul, class RL> class ComposedStrings;


template<class U, long N, long D>
  class ComposedStrings<Loki::Typelist<U, Loki::NullType>, 
           Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType> >
  {
    public:
      static std::string Name (void)
       {return U::Name ()
         + "^(" + BSUtilities::Conversion<long>::to_string(N) 
             + "/" + BSUtilities::Conversion<long>::to_string(D) + ")";}

      static std::string Symbol (void)
       {return U::Symbol ()
         + "^(" + BSUtilities::Conversion<long>::to_string(N) 
             + "/" + BSUtilities::Conversion<long>::to_string(D) + ")";}
  };


template<class U, long N>
  class ComposedStrings<Loki::Typelist<U, Loki::NullType>, 
              Loki::Typelist<BSUtilities::Rational<N>, Loki::NullType> >
  {
    public:
      static std::string Name (void)
       {return U::Name ()
         + "^" + BSUtilities::Conversion<long>::to_string(N);}

      static std::string Symbol (void)
       {return U::Symbol ()
         + "^" + BSUtilities::Conversion<long>::to_string(N);}
  };


template<class U, class UTail, long N, long D, class RTail>
  class ComposedStrings<Loki::Typelist<U, UTail>, 
                    Loki::Typelist<BSUtilities::Rational<N, D>, RTail> >
  {
    public:
      static const std::string Name (void)
        {return U::Name ()
          + "^(" + BSUtilities::Conversion<long>::to_string(N) 
              + "/" + BSUtilities::Conversion<long>::to_string(D) + ")"
                              + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol ()
          + "^(" + BSUtilities::Conversion<long>::to_string(N) 
              + "/" + BSUtilities::Conversion<long>::to_string(D) + ")"
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };


template<class U, class UTail, long N, class RTail>
  class ComposedStrings<Loki::Typelist<U, UTail>, 
                   Loki::Typelist<BSUtilities::Rational<N, 1L>, RTail> >
  {
    public:
      static const std::string Name (void)
        {return U::Name ()
          + "^" + BSUtilities::Conversion<long>::to_string(N) 
                              + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol ()
          + "^" + BSUtilities::Conversion<long>::to_string(N) + " "
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };


template<class U, class UTail, class RTail>
  class ComposedStrings<Loki::Typelist<U, UTail>, 
                  Loki::Typelist<BSUtilities::Rational<1L, 1L>, RTail> >
  {
    public:
      static const std::string Name (void)
        {return U::Name () + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol () + " "
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };



template<class GT, class U, class UTail, class CUL, class ST>
  class Composed<Compound<GT, CUL, ST>, Loki::Typelist<U, UTail> > 
                                         : public Compound<GT, CUL, ST>
  {
    private:
      typedef Loki::Typelist<U, UTail> List;
      typedef Composed<Compound<GT, CUL, ST>, List> Unit;
      typedef Compound<GT, CUL, ST> Comp;

    public:
/*  static access
*/
      static bool Is_SI (void) 
                             {return CheckBoolProperty<List>::is_SI ();}


      bool is_SI (void) const {return Is_SI ();}


      static bool Is_exact (void) 
                          {return CheckBoolProperty<List>::is_exact ();}


      bool is_exact (void) const {return Is_exact ();}


      static ST standardRatio (void) 
        {return ComposedStandard<List,
                  typename Comp::Powers::Result, ST>::StandardRatio ();}


      static ST Standard (const ST value)
                                      {return value * standardRatio ();}


      ST standard (const ST &value) const {return Standard (value);}

/*  static access
*/
      static ST Reverse (const ST value)
                                      {return value / standardRatio ();}

/*  dynamic access
*/
      ST reverse (const ST &value) const {return Reverse (value);}

/*  direct static access to be used if type of unit is known at 
    compile time;
    must not be a static const data member, since it requires access
    to the name values of the individual elementary units; they may 
    not be available yet when they are needed here.
*/
        static std::string Name (void)
          {return ComposedStrings<List, 
                            typename Comp::Powers::Result>::Name ();}


      inline const std::string name (void) const {return Name ();}

/*  direct static access to be used if type of unit is known at 
    compile time;
    must not be a static const data member, since it requires access
    to the symbol values of the individual elementary units; they may 
    not be available yet when they are needed here.
*/
        static std::string Symbol (void)
          {return ComposedStrings<List, 
                             typename Comp::Powers::Result>::Symbol ();}


      inline const std::string symbol (void) const {return Symbol ();}

  };

template<class UList, class CEList> struct GenComposedList;

template<class GT, class U, class UTail, class ST>
  struct GenComposedList<Loki::Typelist<NonPrefixable<GT, U, ST>, 
                                                 UTail>, Loki::NullType>
  {
      typedef 
        Loki::Typelist<Loki::Typelist<NonPrefixable<GT, U, ST>, 
                                                        Loki::NullType>,
          typename GenComposedList<UTail, Loki::NullType>::Result> 
                                                                 Result;
  };

template<class GT, class U, class P, class UTail, class ST>
  struct GenComposedList< 
    Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, P>, UTail>, 
                                                         Loki::NullType>
  {
      typedef 
        Loki::Typelist<Loki::Typelist<Prefixed<Prefixable<GT, U, ST>, 
                                                    P>, Loki::NullType>,
          typename GenComposedList<UTail, Loki::NullType>::Result> 
                                                                 Result;
  };

template<class BC, class EL, class UTail>
  struct GenComposedList<Loki::Typelist<Composed<BC, EL>, UTail>, 
                                                         Loki::NullType>
  {
      typedef Loki::Typelist<Loki::Typelist<Composed<BC, EL>, 
                                                        Loki::NullType>,
        typename GenComposedList<UTail, Loki::NullType>::Result> Result;
  };

template<>
  struct GenComposedList<Loki::NullType, Loki::NullType>
  {
    typedef Loki::NullType Result;
  };

template<class GT1, class U, 
                          class U1, class UTail, class ELTail, class ST>
  struct GenComposedList<NonPrefixable<GT1, U1, ST>, 
                      Loki::Typelist<Loki::Typelist<U, UTail>, ELTail> >
  {
     typedef Loki::Typelist<Loki::Typelist<NonPrefixable<GT1, U1, ST>, 
        Loki::Typelist<U, UTail> >, 
          typename GenComposedList<NonPrefixable<GT1, U1, ST>, 
                                               ELTail> ::Result> Result;
  };

template<class GT, class U, class ST>
  struct GenComposedList<NonPrefixable<GT, U, ST>, Loki::NullType>
  {
      typedef Loki::NullType Result;
  };

template<class GT1, 
      class U, class U1, class P, class UTail, class ELTail, class ST>
  struct GenComposedList<Prefixed<Prefixable<GT1, U1, ST>, P>, 
                      Loki::Typelist<Loki::Typelist<U, UTail>, ELTail> >
  {
     typedef 
       Loki::Typelist<Loki::Typelist<Prefixed<Prefixable<GT1, U1, ST>, 
         P>, Loki::Typelist<U, UTail> >, 
           typename GenComposedList<Prefixed<Prefixable<GT1, U1, ST>, 
                                            P>, ELTail>::Result> Result;
  };

template<class GT, class U, class P, class ST>
  struct 
     GenComposedList<Prefixed<Prefixable<GT, U, ST>, P>, Loki::NullType>
  {
      typedef Loki::NullType Result;
  };

template<class U, class BC1, class EL1, class UTail, class ELTail>
  struct GenComposedList<Composed<BC1, EL1>, 
                      Loki::Typelist<Loki::Typelist<U, UTail>, ELTail> >
  {
    typedef Loki::Typelist<Loki::Typelist<Composed<BC1, EL1>, 
      Loki::Typelist<U, UTail> >, typename GenComposedList< 
                            Composed<BC1, EL1>, ELTail>::Result> Result;
  };

template<class BC1, class EL1>
  struct GenComposedList<Composed<BC1, EL1>, Loki::NullType>
  {
      typedef Loki::NullType Result;
  };

template<class GT1, 
  class U, class U1, class UTail, class U1Tail, class ELTail, class ST>
  struct GenComposedList<Loki::Typelist<NonPrefixable<GT1, U1, ST>, 
                                               UTail>, 
                     Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >
  {
      typedef typename 
        BSUtilities::Concatenate<typename GenComposedList< 
          NonPrefixable<GT1, U1, ST>, 
            Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >::Result,
            typename GenComposedList<UTail, 
              Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> 
                                              >::Result>::Result Result;
  };

template<class GT1, class P,
  class U, class U1, class UTail, class U1Tail, class ELTail, class ST>
  struct GenComposedList<Loki::Typelist<Prefixed<Prefixable<GT1, U1, 
                                      ST>, P>, UTail>, 
                     Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >
  {
      typedef typename BSUtilities::Concatenate<typename 
        GenComposedList<Prefixed<Prefixable<GT1, U1, ST>, P>, 
          Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >::Result,
            typename GenComposedList<UTail,
              Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> 
                                              >::Result>::Result Result;
  };

template<class U, 
  class BC1, class EL1, class UTail, class U1Tail, class ELTail>
  struct GenComposedList<Loki::Typelist<Composed<BC1, EL1>, UTail>, 
                     Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >
  {
     typedef typename 
       BSUtilities::Concatenate<typename GenComposedList< 
         Composed<BC1, EL1>, 
            Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >::Result,
           typename GenComposedList<UTail, 
                               Loki::Typelist<Loki::Typelist<U, U1Tail>,
                                      ELTail> >::Result>::Result Result;
  };

template<class U, class U1Tail, class ELTail>
  struct GenComposedList<Loki::NullType, 
                     Loki::Typelist<Loki::Typelist<U, U1Tail>, ELTail> >
  {
      typedef Loki::NullType Result;
  };

template<class CEL, class ST = double> struct ExpandCompoundElementList;

template<class GT, class UHead, class UTail, long N, long D, 
                                                 class CETail, class ST>
  struct ExpandCompoundElementList< 
    Loki::Typelist<CompoundElement<GT, Loki::Typelist<UHead, UTail>, 
                         BSUtilities::Rational<N, D>, ST>, CETail>, ST>
  {
      typedef typename GenComposedList<typename CompoundElement<GT, 
        Loki::Typelist<UHead, UTail>, 
          BSUtilities::Rational<N, D>, ST>::Units,
            typename ExpandCompoundElementList<CETail>::Result>::Result 
                                                                 Result;
  };

template<>
  struct ExpandCompoundElementList<Loki::NullType>
  {
      typedef Loki::NullType Result;
  };

template<class C, class CEList> struct GenComposedUnits;

template<class GT, class EList, class CELHead, class CELTail, class ST>
  struct GenComposedUnits<Compound<GT, EList, ST>, 
                                      Loki::Typelist<CELHead, CELTail> >
  {
      typedef Loki::Typelist<Composed<Compound<GT, EList, ST>, CELHead>,
        typename GenComposedUnits<Compound<GT, EList, ST>, 
                                               CELTail>::Result> Result;
  };
          
template<class GT, class EList, class ST>
  struct GenComposedUnits<Compound<GT, EList, ST>, Loki::NullType>
  {
      typedef Loki::NullType Result;
  };


template<class EL> struct GenPowers;


template<class EHead, class ETail>
  struct GenPowers<Loki::Typelist<EHead, ETail> >
  {
    typedef Loki::Typelist<typename EHead::Power, 
                              typename GenPowers<ETail>::Result> Result;
  };


template<class EHead>
  struct GenPowers<Loki::Typelist<EHead, Loki::NullType> >
  {
    typedef 
           Loki::Typelist<typename EHead::Power, Loki::NullType> Result;
  };

          

//
//  template Compound
//  a unit compounded from one or more base units
//


template<class GT, class UHead, class UTail, 
  long N, long D, class Tail, class ST> 
  class Compound<GT, Loki::Typelist<CompoundElement<GT, 
        Loki::Typelist<UHead, UTail>, BSUtilities::Rational<N, D>, ST>, 
                                        Tail>, ST> : public Unit<GT, ST>
  {
    private:
      typedef 
        Loki::Typelist<CompoundElement<GT, Loki::Typelist<UHead, UTail>,
                   BSUtilities::Rational<N, D>, ST >, Tail> ElementList;

    public:
      typedef GenPowers<ElementList> Powers;

      typedef typename 
        GenComposedUnits<Compound<GT, ElementList, ST>, typename
          ExpandCompoundElementList<ElementList>::Result>::Result Units;
  };

}

#endif /* _Unit_h */

---