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 - 2010, 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.
*/

#ifndef _Unit_h
#define _Unit_h

// Quantity includes
#include "Quantities/Quantity/Prefix.h"
#include "Quantities/Quantity/UnitError.h"

// BSUtilities includes
#include "BSUtilities/BSUtilities.h"
#include "BSUtilities/TemplateTools.h"
#include "BSUtilities/Conversion.h"
#include "BSUtilities/BoostSpirit.h"

// Loki includes
#include "loki/NullType.h"
#include "loki/EmptyType.h"
#include "loki/TypeManip.h"
#include "loki/Typelist.h"

// STL includes
#include <vector>
#include <string>
#include <climits>

// Boost includes
#include <boost/spirit.hpp>
#include <boost/spirit/actor.hpp>
#include <boost/spirit/phoenix/functions.hpp>


namespace unit {

//
//  Helper classes and structs 
//


template<bool> 
  struct InvalidUnit;


template<class U, class UL> struct ValidUnit;

//
//  the Unit base class template
//


template<class UT> class Unit {};

//
//  the NonPrefixable unit
//


template<class UT, class U> 
  class NonPrefixable : public Unit<UT>
  {
    private:
      static const double StandardFactor;

      static const bool SI;

      static const bool Exact;


      static const std::string Namestring;


      static const std::string Symbolstring;

  public:

    static double Factor (void) {return StandardFactor;}


      static bool IsSI (void) {return SI;}


      static bool IsExact (void) {return Exact;}

/*  static access; call without reference to an object
*/
      static std::string Name (void) {return Namestring;}

/*  static access; call without reference to an object
*/
      static std::string Symbol (void) {return Symbolstring;}

  };

//
//  the Prefixable and Prefixed units
//


template<class UT, class U> class Prefixable : public Unit<UT>
  {
    private:
      static const double StandardFactor;


      static const bool SI;


      static const bool Exact;

    public:

      static double BaseFactor (void) {return StandardFactor;}

/*  static access; call without reference to an object
*/
      static bool IsSI (void) {return SI;}

/*  static access; call without reference to an object
*/
      static bool IsExact (void) {return Exact;}

  protected:
/*  static access; call without reference to an object
*/
      static const std::string Basename;

/*  static access; call without reference to an object
*/
      static const std::string Basesymbol;

  };


template<class BP, class UP = No> class Prefixed;


template<class UT, class U, class UP> 
  class Prefixed<Prefixable<UT, U>, UP> : public Prefixable<UT, U>
  {
    public:
/*  static access;  call without reference to an object 
    get name from prefix and prepend to the base name which is inherited
    from Prefixable<UT, U>
*/
      static std::string Name (void) 
                      {return UP::Name + Prefixable<UT, U>::Basename;}

/*  static access;  call without reference to an object
    get symbol from prefix and prepend to the base symbol which is inherited
    from Prefixable<UT, U>
*/
      static std::string Symbol (void) 
                  {return UP::Symbol + Prefixable<UT, U>::Basesymbol;}

  };

//
//  the ComposeBase and Composed units 
//

//  helper structs: error reporting


template<bool> struct UnitListError;


template<> struct UnitListError<false> {};

//  helper structs: Power string representation


template<long N, long D> 
  struct Power
  {static std::string string (void) 
    {return "^" + BSUtilities::Conversion<long>::to_string(N) + "/" 
               + BSUtilities::Conversion<long>::to_string(D);}
  };

/* template parameter:
   N - the exponent numerator
   specialization for a denominator of 1L; denominator is not shown;
   can be used in static string evaluation
*/
template<long N>
  struct Power<N, 1L>
  {static std::string string (void) 
    {return "^" + BSUtilities::Conversion<long>::to_string(N);}
  };

/* specialization for nominator AND denominator of 1L; power is
   equal to 1 and not shown, returns empty string; can be used in static
   string evaluation
*/
template<>
  struct Power<1L, 1L>
  {static std::string string (void) {return "";}
  };

//  end helper structs


template<typename UL, typename E> class Component;


template<typename UT, typename CL> class ComposeBase;


template<typename UT, typename UL, long N, long D, typename CTail> 
  class ComposeBase<UT, Loki::Typelist<Component<UL,   
                 BSUtilities::Rational<N, D> >, CTail> >: public Unit<UT>
  {
    private:
      static const double StandardFactor;

    public:

      static double BaseFactor (void) {return StandardFactor;}

  };


template<typename UT>
  class ComposeBase<UT, Loki::NullType> : public Unit<UT> {};


template<typename CB, typename CUL> class Composed;


template<typename UT, typename UL, long N, long D, typename CTail, 
                            typename UT1, typename U1, typename CUTail>
  class Composed<ComposeBase<UT, Loki::Typelist<Component<UL, 
    BSUtilities::Rational<N, D> >, CTail> >, 
                           Loki::Typelist<NonPrefixable<UT1, U1>, CUTail> >
    : public  ComposeBase<UT, Loki::Typelist<Component<UL,
                                    BSUtilities::Rational<N, D> >, CTail> >
  {
    public:
      static std::string Symbol (void) 
        {return ValidUnit<NonPrefixable<UT1, U1>, UL>::RET::Symbol() 
         + Power<N, D>::string ()
         + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
           BSUtilities::Blank, BSUtilities::EmptyString>::RET::string() 
         + Composed<ComposeBase<UT, CTail>, 
             typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value, 
                           UnitListError<true>, CUTail>::RET>::Symbol ();}
      static std::string Name (void) 
        {return ValidUnit<NonPrefixable<UT1, U1>, UL>::RET::Name() 
         + Power<N, D>::string ()
         + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
           BSUtilities::Blank, BSUtilities::EmptyString>::RET::string() 
         + Composed<ComposeBase<UT, CTail>, 
             typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value, 
                           UnitListError<true>, CUTail>::RET>::Name ();}
      static bool IsSI (void)
        {return ((NonPrefixable<UT1, U1>::IsSI () 
          && Composed<ComposeBase<UT, CTail>,
            typename BSUtilities::IF<Loki::TL::Length<CTail>::value
              - Loki::TL::Length<CUTail>::value,
                    UnitListError<true>, CUTail>::RET>::IsSI ()) ? 1 : 0);}
      static bool IsExact (void)
        {return ((NonPrefixable<UT1, U1>::IsExact () 
          && Composed<ComposeBase<UT, CTail>,
            typename BSUtilities::IF<Loki::TL::Length<CTail>::value
              - Loki::TL::Length<CUTail>::value,
                 UnitListError<true>, CUTail>::RET>::IsExact ()) ? 1 : 0);}
  };


template<typename UT, typename UL, long N, long D, typename CTail, 
  typename UT1, typename U1, typename UP1, typename CUTail>
  class Composed<ComposeBase<UT, Loki::Typelist<Component<UL, 
    BSUtilities::Rational<N, D> >, CTail> >,
             Loki::Typelist<Prefixed<Prefixable<UT1, U1>, UP1>, CUTail> >
    : public ComposeBase<UT, Loki::Typelist<Component<UL,
                                    BSUtilities::Rational<N, D> >, CTail> >
  {
    public:
      static std::string Symbol (void) 
        {return ValidUnit<Prefixed<Prefixable<UT1, U1>, UP1>, 
                                                        UL>::RET::Symbol() 
           + Power<N, D>::string() 
             + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
               BSUtilities::Blank, BSUtilities::EmptyString>::RET::string()
             + Composed<ComposeBase<UT, CTail>, 
                 typename BSUtilities::IF<Loki::TL::Length<CTail>::value
                     - Loki::TL::Length<CUTail>::value, 
                            UnitListError<true>, CUTail>::RET>::Symbol ();}
      static std::string Name (void) 
        {return ValidUnit<Prefixed<Prefixable<UT1, U1>, UP1>, 
                                                        UL>::RET::Name() 
           + Power<N, D>::string() 
           + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
               BSUtilities::Blank, BSUtilities::EmptyString>::RET::string()
           + Composed<ComposeBase<UT, CTail>, 
               typename BSUtilities::IF<Loki::TL::Length<CTail>::value
                 - Loki::TL::Length<CUTail>::value, 
                           UnitListError<true>, CUTail>::RET>::Name ();}
    static bool IsSI (void)
      {return ((Prefixable<UT1, U1>::IsSI () 
        && Composed<ComposeBase<UT, CTail>,
          typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value,
                    UnitListError<true>, CUTail>::RET>::IsSI ()) ? 1 : 0);}
    static bool IsExact (void)
      {return ((Prefixable<UT1, U1>::IsExact () 
        && Composed<ComposeBase<UT, CTail>,
          typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value,
                 UnitListError<true>, CUTail>::RET>::IsExact ()) ? 1 : 0);}
};


template<typename UT,  typename UL, long N, long D, typename CTail,
  typename UT1, typename CL1, typename UL1, typename CUTail>
  class Composed<ComposeBase<UT, 
    Loki::Typelist<Component<UL, BSUtilities::Rational<N, D> >, CTail> >,
      Loki::Typelist<Composed<ComposeBase<UT1, CL1>, UL1>, CUTail> >
    : public  ComposeBase<UT, Loki::Typelist<Component<UL,
                                    BSUtilities::Rational<N, D> >, CTail> >
  {
    public:
      static std::string Symbol (void) 
      {return BSUtilities::LeftParenthesis::string() 
         + ValidUnit<Composed<ComposeBase<UT1, CL1>, UL1>, 
                                                       UL>::RET::Symbol() 
         + BSUtilities::RightParenthesis::string()
         + Power<N, D>::string()
         + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
                    BSUtilities::Blank, BSUtilities::EmptyString>::RET
                                                              ::string() 
         + Composed<ComposeBase<UT, CTail>,
             typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value,
                            UnitListError<true>, CUTail>::RET>::Symbol ();}
    static std::string Name (void) 
     {return BSUtilities::LeftParenthesis::string() 
         + ValidUnit<Composed<ComposeBase<UT1, CL1>, UL1>, 
                                                       UL>::RET::Name() 
        + BSUtilities::RightParenthesis::string()
        + Power<N, D>::string()
        + BSUtilities::IF<Loki::TL::Length<CUTail>::value, 
            BSUtilities::Blank, BSUtilities::EmptyString>::RET::string() 
        + Composed<ComposeBase<UT, CTail>,
          typename BSUtilities::IF<Loki::TL::Length<CTail>::value
            - Loki::TL::Length<CUTail>::value,
                           UnitListError<true>, CUTail>::RET>::Name ();}
    static bool IsSI (void)
      {return ((Composed<ComposeBase<UT1, CL1>, UL1>::IsSI () 
        && Composed<ComposeBase<UT, CTail>,
          typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value,
                    UnitListError<true>, CUTail>::RET>::IsSI ()) ? 1 : 0);}
    static bool IsExact (void)
      {return ((Composed<ComposeBase<UT1, CL1>, UL1>::IsExact () 
        && Composed<ComposeBase<UT, CTail>,
          typename BSUtilities::IF<Loki::TL::Length<CTail>::value
               - Loki::TL::Length<CUTail>::value,
                 UnitListError<true>, CUTail>::RET>::IsExact ()) ? 1 : 0);}
  };


template<typename UT, typename CL>
  class Composed<ComposeBase<UT, CL>, Loki::NullType>
    : public  ComposeBase<UT, CL>
  {
    public:
      static std::string Symbol (void) {return "";}
      static std::string Name (void) {return "";}
      static bool IsSI (void) {return true;}
      static bool IsExact (void) {return true;}
  };

//  static standardization


template<typename U, long N = 1l, long D = 1l> struct Standard;


template<typename UT, typename U, long N, long D>
  struct Standard<NonPrefixable<UT, U>, N, D>
  {
    template<typename T>
      static T VAL (const T &value)
      {return value * std::pow (T(NonPrefixable<UT, U>::Factor ()),
                               static_cast<double>(N)/static_cast<double>(D));}
  };


template<typename UT, typename U, typename P, long N, long D>
  struct Standard<Prefixed<Prefixable<UT, U>, P>, N, D>
  {
    template<typename T>
      static T VAL (const T &value)
      {return T (value 
         * std::pow (P::Factor * Prefixable<UT, U>::BaseFactor (),
                           static_cast<double>(N)/static_cast<double>(D)));}
  };


template<typename CL, typename UL> struct StandardComposed;


template<typename CUL, long N, long D, typename CTail, 
                                                typename U, typename UTail>
  struct StandardComposed<Loki::Typelist<Component<CUL, 
          BSUtilities::Rational<N, D> >, CTail>, Loki::Typelist<U, UTail> >
  {
    template<typename T>
      static T VAL (const T &value)
      {return Standard<U, N, D>::VAL 
                           (StandardComposed<CTail, UTail>::VAL (value));}
  };


template<>
  struct StandardComposed<Loki::NullType, Loki::NullType>
  {
    template<typename T> static T VAL (const T &value) {return value;}
  };


template<typename UT, typename CL, typename UL, long N, long D>
  struct Standard<Composed<ComposeBase<UT, CL>, UL>, N, D>
  {
    template<typename T>
      static T VAL (const T &value)
      {return value * std::pow(StandardComposed<CL, UL>::VAL (1.0)
         * ComposeBase<UT, CL>::BaseFactor (),
                              static_cast<double>(N)/static_cast<double>(D));}
  };

//  static reverse standardization


template<typename U, long N = 1l, long D = 1l> struct Reverse;


template<typename UT, typename U, long N, long D>
  struct Reverse<NonPrefixable<UT, U>, N, D>
  {
    template<typename T>
      static T VAL (const T &value)
      {return value / (std::pow (T(NonPrefixable<UT, U>::Factor ()), 
                        static_cast<double>(N)/static_cast<double>(D)));}
  };


template<typename UT, typename U, typename P, long N, long D>
  struct Reverse<Prefixed<Prefixable<UT, U>, P>, N, D>
  {
    template<typename T>
      static T VAL (const T &value)
      {return T (value 
        / std::pow (P::Factor * Prefixable<UT, U>::BaseFactor (),
                         static_cast<double>(N)/static_cast<double>(D)));}
    };


template<typename CL, typename UL> struct ReverseComposed;
  

template<typename CUL, long N, long D, typename CTail, typename U, 
                                                             typename UTail>
  struct ReverseComposed<Loki::Typelist<Component<CUL, 
           BSUtilities::Rational<N, D> >, CTail>, Loki::Typelist<U, UTail> >
  {
    template<typename T>
      static T VAL (const T &value)
      {return Reverse<U, N, D>::VAL 
                             (ReverseComposed<CTail, UTail>::VAL (value));}
  };
  

template<>
  struct ReverseComposed<Loki::NullType, Loki::NullType>
  {
    template<typename T> static T VAL (const T &value) {return value;}
  };


  template<typename UT, typename CL, typename UL, long N, long D>
    struct Reverse<Composed<ComposeBase<UT, CL>, UL>, N, D>
    {
      template<typename T>
      static T VAL (const T &value)
        {return value * std::pow(ReverseComposed<CL, UL>::VAL (1.0)
            / ComposeBase<UT, CL>::BaseFactor (),
                static_cast<double>(N)/static_cast<double>(D));
        }
    };

//  check validity of a unit


template<typename U, typename UT, typename U1, typename UTail> 
  struct ValidUnit<U, Loki::Typelist<NonPrefixable<UT, U1>, UTail> >
  {
    typedef 
      typename BSUtilities::IF<BSUtilities::SameType<U, 
        NonPrefixable<UT, U1> >::sameType, U, 
                       typename ValidUnit<U, UTail>::RET >::RET RET;
  };


template<typename U, typename PU, typename PL> class ValidPrefixedUnit;


template<typename U, typename UT, typename U1, typename P, typename PTail>
  class ValidPrefixedUnit<U, Prefixable<UT, U1>, 
                                   Loki::Typelist<Prefix<P>, PTail> >
  {
    public:
      typedef typename BSUtilities::IF<BSUtilities::SameType<U,
        Prefixed<Prefixable<UT, U1>, Prefix<P> > >::sameType, U, 
          typename ValidPrefixedUnit<U, Prefixable<UT, U1>, 
                                                   PTail>::RET >::RET RET;
  };


template<typename U, typename UT, typename U1>
  class ValidPrefixedUnit<U, Prefixable<UT, U1>, Loki::NullType>
  {
    public: 
      typedef Loki::NullType RET;
  };


template<typename U, typename UT, typename U1, typename UTail> 
  struct ValidUnit<U, Loki::Typelist<Prefixable<UT, U1>, UTail> >
  {
    typedef typename BSUtilities::IF<BSUtilities::SameType<
      typename ValidPrefixedUnit<U, Prefixable<UT, U1>, Prefixes>::RET, 
        Loki::NullType>::sameType, typename ValidUnit<U, UTail>::RET, 
                                                             U>::RET RET;
  };


template<typename CL, typename UL> struct ComposingUnits;


template<typename CUL, long N, long D, typename CTail, typename U, 
                                                          typename UTail> 
  struct ComposingUnits<Loki::Typelist<Component<CUL, 
         BSUtilities::Rational<N, D> >, CTail>, Loki::Typelist<U, UTail> >
  {
    typedef Loki::Typelist<typename ValidUnit<U, CUL>::RET, 
                        typename ComposingUnits<CTail, UTail>::RET> RET;
  };
  

template<>
  struct ComposingUnits<Loki::NullType, Loki::NullType>
{
  typedef Loki::NullType RET;
};
  

template<typename U, typename CB> struct ValidComposedUnit;


template<typename UT, typename CL, typename UL>
  struct ValidComposedUnit<Composed<ComposeBase<UT, CL>, UL>,
      ComposeBase<UT, CL> >
  {
    public: 
      typedef typename BSUtilities::IF<BSUtilities::SameType<
        Composed<ComposeBase<UT, CL>, typename ComposingUnits<CL, UL>::RET>,
         Composed<ComposeBase<UT, CL>, UL> >::sameType, 
                 Composed<ComposeBase<UT, CL>, UL>, Loki::NullType>::RET RET;
  };


template<typename U, typename UT, typename CL>
  struct ValidComposedUnit<U, ComposeBase<UT, CL> >
  {
    public: 
      typedef Loki::NullType RET;
  };


template<typename U, typename UT>
  struct ValidComposedUnit<U, ComposeBase<UT, Loki::NullType> >
  {
    public: 
      typedef Loki::NullType RET;
  };


template<typename U, typename UT, typename CL, typename UTail> 
  struct ValidUnit<U, Loki::Typelist<ComposeBase<UT, CL>, UTail> >
  {
    typedef typename BSUtilities::IF<BSUtilities::SameType<
      typename ValidComposedUnit<U, ComposeBase<UT, CL> >::RET, 
        Loki::NullType>::sameType, typename ValidUnit<U, UTail>::RET, 
                                                            U>::RET RET;
  };



template<typename U>
  struct ValidUnit<U, Loki::NullType>
  {
    typedef InvalidUnit<true> RET;
  };

//  dynamic standardization


template<typename UL, long N = 1l, long D = 1l> struct standard;


template<typename UT, typename U, typename UTail, long N, long D>
  struct standard<Loki::Typelist<NonPrefixable<UT, U>, UTail>, N, D>
  {template<typename T>
     static T VAL (const T &value, const std::string &symbol)
     {if (NonPrefixable<UT, U>::Symbol () == symbol)
        return Standard<NonPrefixable<UT, U>, N, D>::VAL (value);
      else
        return standard<UTail, N, D>::VAL (value, symbol);
     }
  };

/*  template parameters:
    U  - the base Prefixable unit
    PL - a list of prefixes
    N  - the numerator of the exponent
    D  - the denominator of the exponent
    primary template
*/
template<typename U, typename PL, long N = 1l, long D = 1l> 
                                                 struct standardPrefixed;
         

template<typename UT, typename U1, typename P, typename PTail, 
                                                       long N, long D>
  struct standardPrefixed<Prefixable<UT, U1>, 
                              Loki::Typelist<Prefix<P>, PTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {if (Prefixed<Prefixable<UT, U1>, Prefix<P> >::Symbol () == symbol)
         return Standard<Prefixed<Prefixable<UT, U1>, 
                                    Prefix<P> >, N, D>::VAL (value);
       else
         return standardPrefixed<Prefixable<UT, U1>,
                                   PTail, N, D>::VAL (value, symbol);
      }
    };


template<typename UT, typename U1, long N, long D>
  struct standardPrefixed<Prefixable<UT, U1>, Loki::NullType, N, D>
  {
    template<typename T>
      static T VAL (const T &, const std::string &)
                {throw UnitMismatch (); return T (0);}
  };


template<typename UT, typename U, typename UTail, long N, long D>
  struct standard<Loki::Typelist<Prefixable<UT, U>, UTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {try {return standardPrefixed <Prefixable<UT, U>, Prefixes, N, D>::VAL 
                                                           (value, symbol);
           }
       catch (UnitMismatch)
                        {return standard<UTail, N, D>::VAL (value, symbol);}
      }
  };

/*  template parameter:
    CB - the compose base unit
    primary template
*/
template<typename CB> struct standardComposed;

/*  template parameters
    UT    - the unit type of the composed base
    CUL   - the unit list of the first component in the component list
    N     - the numerator of the exponent
    D     - the denominator of the exponent
    CTail - the remaining components
    specialization for CB being a composed unit;
    if the first numerator and the first denominator in the respective lists
    determined from the unit symbol string and stored per component in a
    std::vector, respectively, are equal to N and D, the first unit symbol
    string (and the numerator and denominator) are used to standardize the
    return value of a recursive call to standardComposed with the rest of the
    unit, numerator and denominator lists; if the numerator and denominator
    of the exponent are incompatible, a UnitMismatch exception is thrown;
    VAL is parameterized with the type T of 
    the value, which is also the return type; T is automatically determined 
    by argument deduction.
*/
template<typename UT, typename CUL, long N, long D, typename CTail>
  struct standardComposed<ComposeBase<UT, 
      Loki::Typelist<Component<CUL, BSUtilities::Rational<N, D> >, CTail> > >
  {
    template<typename T>
      static T VAL (const T &value, std::vector<std::string> &symbols, 
                std::vector<long> &numerators, std::vector<long> &denominators)
      {if ((numerators[0] == N) && (denominators[0] == D))
         {std::string symbol = symbols[0];
          symbols.erase(symbols.begin());
          numerators.erase(numerators.begin());
          denominators.erase(denominators.begin());
          return standard<CUL, N, D>::VAL 
            (standardComposed<ComposeBase<UT, CTail> >
                    ::VAL (value, symbols, numerators, denominators), symbol);
         }
       else 
         throw UnitInputError ("invalid exponent in unit symbol!"); 
      }
  };
  
/*  template parameters
    UT    - the unit type of the composed base
    CUL   - the unit list of the first component in the component list
    N     - the numerator of the exponent
    D     - the denominator of the exponent
    specialization for CB being a compose base unit and last component reached;
    end recursion;
    if the first numerator and the first denominator in the respective lists
    determined from the unit symbol string and stored per component in a
    std::vector, respectively, are equal to N and D, the first unit symbol
    string (and the numerator and denominator) are used to standardize the
    return value of a recursive call to standardComposed with the rest of the
    unit, numerator and denominator lists; if the numerator and denominator
    of the exponent are incompatible, a UnitMismatch exception is thrown;
    VAL is parameterized with the type T of 
    the value, which is also the return type; T is automatically determined 
    by argument deduction.
*/
template<typename UT, typename CUL, long N, long D>
  struct standardComposed<ComposeBase<UT, Loki::Typelist<Component<CUL, 
                     BSUtilities::Rational<N, D> >, Loki::NullType> > >
  {
    template<typename T>
      static T VAL (const T &value, std::vector<std::string> &symbols, 
              std::vector<long> &numerators, std::vector<long> &denominators)
      {if ((numerators[0] == N) && (denominators[0] == D))
         {return standard<CUL, N, D>::VAL (value, symbols[0]);}
       else
         throw UnitInputError ("invalid exponent in unit symbol!"); 
      }
  };


struct ComposedClosure 
                  : boost::spirit::closure<ComposedClosure, std::string>
{
  member1 unit;
};


class ComposedGrammar : public boost::spirit::grammar<ComposedGrammar>
{
  private:
    std::vector<std::string> &symbols;
    std::vector<long> &numerators;
    std::vector<long> &denominators;
    static boost::spirit::int_parser<long> long_p;
    static boost::spirit::uint_parser<long> ulong_p;

  public:

    ComposedGrammar (std::vector<std::string> &_symbols, 
      std::vector<long> & _numerators, std::vector<long> &_denominators) 
        : symbols(_symbols), numerators (_numerators), 
                                        denominators (_denominators) {}
  public:
    template<typename ScannerT>
      struct definition
      {
        boost::spirit::rule<ScannerT, ComposedClosure::context_t> 
                                                               component;
        boost::spirit::rule<ScannerT> composed, symbol, composedComponent, 
                                        exponent, numerator, denominator;

        definition (ComposedGrammar const& self)
        {
// inititalize component.unit to empty string; upon success (component found)
// store in vector symbols to be used outside grammar
// use closure to allow recursion
          composed = component("")
            [BSUtilities::push_back(phoenix::var(self.symbols), 
                                                     phoenix::arg1)] % ' ';
          component = symbol >> exponent;
          exponent = ('^' >> numerator >> (('/' >> denominator) 
            | boost::spirit::eps_p
              [BSUtilities::push_back(phoenix::var(self.denominators), 
                                                      phoenix::val(1))])) 
            | boost::spirit::eps_p
              [BSUtilities::push_back(phoenix::var(self.numerators), 
                phoenix::val(1))][BSUtilities::push_back
                  (phoenix::var(self.denominators), phoenix::val(1))];
          numerator = 
            long_p[BSUtilities::push_back(phoenix::var(self.numerators), 
                                                        phoenix::arg1)];
          denominator = ulong_p
            [BSUtilities::push_back(phoenix::var(self.denominators), 
                                                        phoenix::arg1)];
          composedComponent = '(' >> (*(composedComponent |
            (boost::spirit::anychar_p - ')')))
              [component.unit = phoenix::construct_<std::string> 
                                 (phoenix::arg1, phoenix::arg2)] >> ')';
          symbol = (+boost::spirit::alpha_p)
            [component.unit = phoenix::construct_<std::string> 
                 (phoenix::arg1, phoenix::arg2)] | composedComponent;
        }

        boost::spirit::rule<ScannerT> const & start (void) const 
                                                    {return composed;}
      };
};


template<typename UT, typename CUL, long N1, long D1, 
                         typename CTail, typename UTail, long N, long D>
  struct standard<Loki::Typelist<ComposeBase<UT, 
    Loki::Typelist<Component<CUL, BSUtilities::Rational<N1, D1> >, 
                                                 CTail> >, UTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {try {std::vector<std::string> symbols;
            std::vector<long> numerators;
            std::vector<long> denominators;
            ComposedGrammar cg (symbols, numerators, denominators);
            if (boost::spirit::parse(symbol.c_str(), cg).full)
              return standardComposed<ComposeBase<UT, 
                Loki::Typelist<Component<CUL, BSUtilities::Rational<N1, D1> >, 
                  CTail> > >::VAL (value, symbols, numerators, denominators)
                    * std::pow (ComposeBase<UT, Loki::Typelist<Component<CUL, 
                      BSUtilities::Rational<N1, D1> >, CTail> >::BaseFactor (), 
                                static_cast<double>(N)/static_cast<double>(D));
            else
             throw UnitSyntaxError ("syntax error in unit symbol!"); 

            }
       catch (UnitMismatch)
         {return standard<UTail, N, D>::VAL (value, symbol);}
       catch (UnitInputError)
         {return standard<UTail, N, D>::VAL (value, symbol);}
      }
    };


template<long N, long D>
  struct standard<Loki::NullType, N, D>
  {
    template<typename T>
      static T VAL (const T &, const std::string &)
           {throw UnitMismatch ("unit symbol not found!"); return T (0);}
  };

//  dynamic reverse standardization


template<typename UL, long N = 1l, long D = 1l> struct reverse;


template<typename UT, typename U, typename UTail, long N, long D>
  struct reverse<Loki::Typelist<NonPrefixable<UT, U>, UTail>, N, D >
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {if (NonPrefixable<UT, U>::Symbol () == symbol)
         return Reverse<NonPrefixable<UT, U>, N, D>::VAL (value);
       else
         return reverse<UTail>::VAL (value, symbol);
      }
  };

/*  template parameters:
    U  - the base Prefixable unit
    PL - a list of prefixes
    N  - the numerator of the exponent
    D  - the denominator of the exponent
    primary template
*/

template<typename U, typename PL, long N = 1l, long D = 1l> 
                                               struct reversePrefixed;
         

template<typename UT, typename U1, typename P, typename PTail, 
                                                         long N, long D>
  struct reversePrefixed<Prefixable<UT, U1>, 
                                 Loki::Typelist<Prefix<P>, PTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {if (Prefixed<Prefixable<UT, U1>, Prefix<P> >::Symbol () == symbol)
         return Reverse<Prefixed<Prefixable<UT, U1>, 
                                         Prefix<P> >, N, D>::VAL (value);
       else
         return reversePrefixed<Prefixable<UT, U1>,
                                       PTail, N, D>::VAL (value, symbol);
      }
  };


template<typename UT, typename U1, long N, long D>
  struct reversePrefixed<Prefixable<UT, U1>, Loki::NullType, N, D>
  {
    template<typename T>
      static T VAL (const T &, const std::string &)
                                    {throw UnitMismatch (); return T (0);}
  };


template<typename UT, typename U, typename UTail, long N, long D>
  struct reverse<Loki::Typelist<Prefixable<UT, U>, UTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {try {return reversePrefixed <Prefixable<UT, U>, Prefixes, N, D>::VAL 
                                                           (value, symbol);
           }
       catch (UnitMismatch)
                        {return reverse<UTail, N, D>::VAL (value, symbol);}
      }
  };

/*  template parameter:
    CB - the compose base unit
    primary template
*/
template<typename CB> struct reverseComposed;

/*  template parameters
    UT    - the unit type of the composed base
    CUL   - the unit list of the first component in the component list
    N     - the numerator of the exponent
    D     - the denominator of the exponent
    CTail - the remaining components
    specialization for CB being a compose base unit; recursive template;
    if the first numerator and the first denominator in the respective lists
    determined from the unit symbol string and stored per component in a
    std::vector, respectively, are equal to N and D, the first unit symbol
    string (and the numerator and denominator) are used to reverse standardize 
    the return value of a recursive call to reverseComposed with the rest of the
    unit, numerator and denominator lists; if the numerator and denominator
    of the exponent are incompatible, a UnitMismatch exception is thrown;
    VAL is parameterized with the type T of 
    the value, which is also the return type; T is automatically determined 
    by argument deduction.
*/
template<typename UT, typename CUL, long N, long D, typename CTail>
  struct reverseComposed<ComposeBase<UT, 
      Loki::Typelist<Component<CUL, BSUtilities::Rational<N, D> >, CTail> > >
  {
    template<typename T>
      static T VAL (const T &value, std::vector<std::string> &symbols, 
                std::vector<long> &numerators, std::vector<long> &denominators)
      {if ((numerators[0] == N) && (denominators[0] == D))
         {std::string symbol = symbols[0];
          symbols.erase(symbols.begin());
          numerators.erase(numerators.begin());
          denominators.erase(denominators.begin());
          return reverse<CUL, N, D>::VAL 
            (reverseComposed<ComposeBase<UT, CTail> >
                    ::VAL (value, symbols, numerators, denominators), symbol);
         }           
       else 
         throw UnitInputError ("invalid exponent in unit symbol!"); 
      }
  };
  
/*  template parameters
    UT    - the unit type of the composed base
    CUL   - the unit list of the first component in the component list
    N     - the numerator of the exponent
    D     - the denominator of the exponent
    specialization for CB being a compose base unit with CTail being 
    Loki::NullType; last component is reached; end recursion;
    if the first numerator and the first denominator in the respective lists
    determined from the unit symbol string and stored per component in a
    std::vector, respectively, are equal to N and D, the first unit symbol
    string (and the numerator and denominator) are used to reverse standardize 
    the return value of a recursive call to reverseComposed with the rest of the
    unit, numerator and denominator lists; if the numerator and denominator
    of the exponent are incompatible, a UnitMismatch exception is thrown;
    VAL is parameterized with the type T of 
    the value, which is also the return type; T is automatically determined 
    by argument deduction.
*/
template<typename UT, typename CUL, long N, long D>
  struct reverseComposed<ComposeBase<UT, Loki::Typelist<Component<CUL,
                     BSUtilities::Rational<N, D> >, Loki::NullType> > >
  {
    template<typename T>
      static T VAL (const T &value, std::vector<std::string> &symbols, 
                std::vector<long> &numerators, std::vector<long> &denominators)
      {if ((numerators[0] == N) && (denominators[0] == D))
         {return reverse<CUL, N, D>::VAL (value, symbols[0]);}
       else
         throw UnitInputError ("invalid exponent in unit symbol!"); 
      }
  };


template<typename UT, typename CUL, long N1, long D1, 
                         typename CTail, typename UTail, long N, long D>
  struct reverse<Loki::Typelist<ComposeBase<UT, 
    Loki::Typelist<Component<CUL, BSUtilities::Rational<N1, D1> >, 
                                                 CTail> >, UTail>, N, D>
  {
    template<typename T>
      static T VAL (const T &value, const std::string &symbol)
      {try {std::vector<std::string> symbols;
            std::vector<long> numerators;
            std::vector<long> denominators;
            ComposedGrammar cg (symbols, numerators, denominators);
            if (boost::spirit::parse(symbol.c_str(), cg).full)
              return reverseComposed<ComposeBase<UT, 
                Loki::Typelist<Component<CUL, BSUtilities::Rational<N1, D1> >, 
                  CTail> > >::VAL (value, symbols, numerators, denominators)
                    / std::pow (ComposeBase<UT, Loki::Typelist<Component<CUL, 
                      BSUtilities::Rational<N1, D1> >, CTail> >::BaseFactor (), 
                                static_cast<double>(N)/static_cast<double>(D));
            else
             throw UnitSyntaxError ("syntax error in unit symbol!"); 
           }
       catch (UnitMismatch)
                    {return reverse<UTail, N, D>::VAL (value, symbol);}
       catch (UnitInputError)
         {return standard<UTail, N, D>::VAL (value, symbol);}
      }
    };


template<long N, long D>
  struct reverse<Loki::NullType, N, D>
  {
    template<typename T>
      static T VAL (const T &, const std::string &)
                         {throw UnitMismatch (); return T (0);}
  };

}

#endif /* _Unit_h */

---