Variable.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2006, 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 _Variable_h
#define _Variable_h

#include "Quantity/Quantity.h"
#include "Quantity/QuantityError.h"
#include "Quantity/Generic.h"
#include "Quantity/Dynamic.h"
#include "Quantity/Dedimensionalization.h"

#include "Typelist.h"
#include "NullType.h"
#include "Functor.h"
#include "HierarchyGenerators.h"

namespace quantity {

//
//  Helper classes and structs for compiling error messages
//


template<bool> 
  struct VariableError;


template<bool> 
  struct ReturnError;


template<bool>
  struct AssignmentError;


template<>
  struct AssignmentError<false>
    {

       static const bool RET = true;
    };


template<bool>
  struct OperationError;


template<>
  struct OperationError<false>
    {

       static const bool RET = true;
    };

//
//  helper classes and structs for checking features of quantities
//


template<class Q1, class Q2> struct SameDimensioned;


template<template<class, class, class> class Q1, class UT1,
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, 
          class UL1, class DU1, class U1, class ST1,
         template<class, class, class> class Q2, class UT2, 
           long RL2_N, long RL2_D, long RM2_N, long RM2_D,  
             long RT2_N, long RT2_D, long RE2_N, long RE2_D,  
               long RTE2_N, long RTE2_D, long RA2_N, long RA2_D,  
                 long RLU2_N, long RLU2_D, 
           class UL2, class DU2, class U2, class ST2, 
                                                     class N1, class N2>
  struct SameDimensioned
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>, 
        BSUtilities::Rational<RM1_N, RM1_D>, 
          BSUtilities::Rational<RT1_N, RT1_D>, 
            BSUtilities::Rational<RE1_N, RE1_D>, 
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>, 
                  BSUtilities::Rational<RLU1_N, RLU1_D> >, 
                                          UT1, UL1, DU1, ST1>, U1, N1>,
    Q2<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL2_N, RL2_D>, 
        BSUtilities::Rational<RM2_N, RM2_D>, 
          BSUtilities::Rational<RT2_N, RT2_D>, 
            BSUtilities::Rational<RE2_N, RE2_D>, 
              BSUtilities::Rational<RTE2_N, RTE2_D>,
                BSUtilities::Rational<RA2_N, RA2_D>, 
                  BSUtilities::Rational<RLU2_N, RLU2_D> >, 
                                         UT2, UL2, DU2, ST2>, U2, N2> >
  {
    enum {RET = dimension::Equal<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>, 
        BSUtilities::Rational<RM1_N, RM1_D>, 
          BSUtilities::Rational<RT1_N, RT1_D>, 
            BSUtilities::Rational<RE1_N, RE1_D>, 
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>, 
                  BSUtilities::Rational<RLU1_N, RLU1_D> >, 
      dimension::Dimension<BSUtilities::Rational<RL2_N, RL2_D>, 
        BSUtilities::Rational<RM2_N, RM2_D>, 
          BSUtilities::Rational<RT2_N, RT2_D>, 
            BSUtilities::Rational<RE2_N, RE2_D>, 
              BSUtilities::Rational<RTE2_N, RTE2_D>,
                BSUtilities::Rational<RA2_N, RA2_D>, 
                  BSUtilities::Rational<RLU2_N, RLU2_D> > >::EQ}; 
  };



template<class Q1, class Q2> struct CheckSecondDimension;

template<template<class, class, class> class Q1, class UT1, class D1, 
           class UL1, class DU1, class U1, class ST1, class N1,
         template<class, class, class> class Q2, class UT2, class D2, 
           class UL2, class DU2, class U2, class ST2, class N2>
  struct CheckSecondDimension
    <Q1<Quantity<D1, UT1, UL1, DU1, ST1>, U1, N1>, 
         Q2<Quantity<D2, UT2, UL2, DU2, ST2>, U2, N2> >
  {
    private:
      typedef Q1<Quantity<D1, UT1, UL1, DU1, ST1>, U1, N1> Quant1; 
      typedef Q2<Quantity<D2, UT2, UL2, DU2, ST2>, U2, N2> Quant2; 

    public: 
      typedef 
        typename BSUtilities::IF<SameDimensioned<Quant1, Quant2>::RET, 
                                Quant2, DimensionError<true> >::RET RET;
  };

//
//  forward declaration
//


template<class Q1, class Q2> struct GenerateVariable;

//
//  the Variable classes
//


template<class PQ, class SU = typename PQ::DefaultUnit::Unit,
  class DD = typename DefaultDedimensionalizer<PQ, SU>::F> 
                                                         class Variable;


template<long RL_N, long RL_D, long RM_N, long RM_D, 
  long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D,
    long RA_N, long RA_D, long RLU_N, long RLU_D, 
             class BT, class UL, class DU, class SU, class ST, class R,
                                                   class DDH, class DDT>
  class Variable<Quantity<dimension::Dimension<
            BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,  
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>, 
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >, BT, UL, DU, ST>,
                  SU, Loki::Functor<R, Loki::Typelist<DDH, DDT> > > 
      : public 
      Quantity<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,  
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>, 
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >, BT, UL, DU, ST>
    {
      public:

        typedef dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
            BSUtilities::Rational<RM_N, RM_D>,  
              BSUtilities::Rational<RT_N, RT_D>,
                BSUtilities::Rational<RE_N, RE_D>,
                  BSUtilities::Rational<RTE_N, RTE_D>, 
                    BSUtilities::Rational<RA_N, RA_D>,
                              BSUtilities::Rational<RLU_N, RLU_D> > DIM;

        typedef typename Loki::Typelist<DDH, DDT> DDL;
 

        typedef typename Loki::TL::TypeAt<DDL, 0>::Result DDP;

        typedef typename Loki::Functor<R, DDL> DD;


        typedef Quantity<DIM, BT, UL, DU, ST> ABQ;


        typedef Variable<ABQ, SU, DD> V;


        typedef ABQ PQ;

        typedef typename BSUtilities::IF<BSUtilities::SameType
          <DD, typename DefaultDedimensionalizer<PQ, SU>::F>::sameType,
                                       DedimReturn<PQ, SU>, V>::RET DDR;

      private:

        static DDR defaultDedimensionalizer (DDP) {return DDR(ST(1.));}


        static const DD _defaultDD;


        DD _dedimensionalizer;


        ST _value;

      public:

        typedef 
               typename unit::CheckUnit<unit::Unit<BT>, SU>::Check Unit;


        Variable (void) : ABQ (), _dedimensionalizer (_defaultDD), 
                                                       _value (ST(0)) {}


        Variable (const DD &dedimensionalizer)
          : ABQ (), _dedimensionalizer (dedimensionalizer), 
                                                       _value (ST(0)) {}


        Variable (const ST value) 
             : ABQ (), _dedimensionalizer (_defaultDD), _value (value) {}


        Variable (const ST value, const DD &dedimensionalizer) 
          : ABQ (), _dedimensionalizer (dedimensionalizer), 
                                                       _value (value) {}


        Variable (const ST value, const SU &) 
             : ABQ (), _dedimensionalizer (_defaultDD), _value (value) {}
            

        Variable 
          (const ST value, const SU &, const DD &dedimensionalizer) 
            : ABQ (), _dedimensionalizer (dedimensionalizer), 
                                                       _value (value) {}
            

        template<class NU>
          Variable (const ST value, const NU &) 
            : ABQ (), _value (Reverse<SU, ST>::VAL
              (Standardize<typename CheckAgainstAllUnits<NU, UL>::RET, 
                                                   ST>::VAL (value))) {}


        Variable (const ST value, const std::string &symbol) 
          : ABQ ()
            {::unit::Unit<BT> *unitp = PQ::findBySymbol (symbol);

             _value = Reverse<SU, ST>::VAL 
                         (dynamic_standardize<UL>::VAL (value, *unitp));

             delete (unitp);
            }


        Variable (const ST value, const char * symbol) 
          : ABQ ()
            {::unit::Unit<BT> *unitp 
                              = PQ::findBySymbol (std::string (symbol));
             _value = Reverse<SU, ST>::VAL 
                         (dynamic_standardize<UL>::VAL (value, *unitp));

             delete (unitp);
            }


        template<template<class, class, class> class Q1>
          Variable (const Q1<PQ, SU, DD> &quantity) 
            : ABQ (), _value (quantity.value ())
              {namestring = quantity.name ();
               symbolstring = quantity.symbol ();
              }
 

        template<template<class, class, class> class Q1, 
                                                   class SU1, class DD1>
          Variable (const Q1<PQ, SU1, DD1> &quantity)
            : ABQ (), _value (Reverse<SU, ST>::VAL 
                        (Standardize<SU1, ST>::VAL (quantity.value ())))
              {namestring = quantity.name ();
               symbolstring = quantity.symbol ();
              }


        template<template<class, class, class> class Q1, 
                 class BT1, class DIM1, class DU1, class SU1, class DD1>
          Variable (const Q1<Quantity<DIM1, BT1,
            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
                         Loki::NullType>, DU1, ST>, SU1, DD1> &quantity)
            : ABQ (), _value (Reverse<Unit, ST>::VAL
              (Standardize<typename
                 CheckSecondDimension<Variable<PQ, SU, DD>, 
                   Q1<Quantity<DIM1, BT1,
                     Loki::Typelist<unit::NonPrefixable<BT1, 
                       unit::GenericUnit>, Loki::NullType>, 
                         DU1, ST>, SU1, DD1> >::RET::Unit, ST>::VAL
                                                   (quantity.value ())))
              {namestring = quantity.name ();
               symbolstring = quantity.symbol ();
              }


        template<template<class, class, class> class Q1, 
          class PQ1, class SU1, class DD1> 
                                   Variable (const Q1<PQ1, SU1, DD1> &);


        Variable (const Dynamic<ST> &dynamic)
          {if (dynamic._rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
             && dynamic._rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
             && dynamic._rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
             && dynamic._rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
             && dynamic._rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
             && dynamic._rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
             && dynamic._re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
             && dynamic._re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
             && dynamic._rte_n 
                            == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
             && dynamic._rte_d 
                            == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
             && dynamic._ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
             && dynamic._ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
             && dynamic._rlu_n 
                            == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
             && dynamic._rlu_d 
                           == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)

               _value = Reverse<SU, ST>::VAL (dynamic.value ());

            else
               {throw DimensionMismatch ();}

          }


        Variable & operator= (const Variable &new_variable)
          {if (this != &new_variable)
             {_value = new_variable.value ();}

           return *this;
          }


        template<template<class, class, class> class Q1, 
                                                   class SU1, class DD1>
          Variable & operator= (const Q1<PQ, SU1, DD1> &quantity)
          {
            void *this_pointer = this;
            const void *new_pointer = &quantity;

            if (this_pointer != new_pointer)
            {_value = Reverse<SU, ST>::VAL
                        (Standardize<SU1, ST>::VAL (quantity.value ()));
            }

            return *this;
          }


        template<template<class, class, class> class Q1, 
          class PQ1, class SU1, class DD1>
          Variable & operator= (const Q1<PQ1, SU1, DD1> &quantity)
          {
            static const bool RET = 
              BSUtilities::IF<BSUtilities::SameType<PQ, PQ1>::sameType, 
                DimensionError<false>, DimensionError<true> >::RET::RET;
            return *this;
          }


        template<template<class, class, class> class Q1, 
                 class BT1, class DIM1, class DU1, class SU1, class DD1>
          Variable & operator= (const Q1<Quantity<DIM1, BT1,
            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
                         Loki::NullType>, DU1, ST>, SU1, DD1> &quantity)
            {void *this_pointer = this;
             const void *new_pointer = &quantity;

             if (this_pointer != new_pointer)
             {_value = Reverse<SU, ST>::VAL
               (Standardize<typename
                 CheckSecondDimension<Variable<PQ, SU, DD>, 
                   Q1<Quantity<DIM1, BT1,
                     Loki::Typelist<unit::NonPrefixable<BT1,
                       unit::GenericUnit>, Loki::NullType>, 
                         DU1, ST>, SU1, DD1> >::RET::Unit, ST>::VAL
                                                   (quantity.value ()));
             }
             return *this;
            }


          Variable & operator= (const Dynamic<ST> &dynamic)
            {if (dynamic._rl_n == RL_N && dynamic._rl_d == RL_D &&
                 dynamic._rm_n == RM_N && dynamic._rm_d == RM_D &&
                 dynamic._rt_n == RT_N && dynamic._rt_d == RT_D &&
                 dynamic._re_n == RE_N && dynamic._re_d == RE_D &&
                 dynamic._rte_n == RTE_N && dynamic._rte_d == RTE_D &&
                 dynamic._ra_n == RA_N && dynamic._ra_d == RA_D &&
                 dynamic._rlu_n == RLU_N && dynamic._rlu_d == RLU_D)
               _value = Reverse<SU, ST>::VAL (dynamic.value ());

             else
               {throw DimensionMismatch ();}

             return *this;
            }


        ST value (void) const {return _value;}


        ST standard_value (void) const 
                     {return Standardize<SU, ST>::VAL (_value);}


        template<class NU>
          ST value (const unit::NonPrefixable<BT, NU> &) const 
            {return Reverse<typename CheckAgainstAllUnits<
              unit::NonPrefixable<BT, NU>, UL>::RET, ST>::VAL
                           (Standardize<SU, ST>::VAL (_value));}


        template<class NU, class P>
          ST value 
            (const unit::Prefixed<unit::Prefixable<BT, NU>, P> &) const
            {return Reverse<typename CheckAgainstAllUnits<
              unit::Prefixed<unit::Prefixable<BT, NU>, P>, UL>::RET, 
                  ST>::VAL (Standardize<SU, ST>::VAL (_value));}


        template<class CUL, class EL>
          ST value 
            (const unit::Composed<unit::ComposeBase<BT, CUL>, EL> &)
                                                                   const
            {return Reverse<typename CheckAgainstAllUnits<
              unit::Composed<unit::ComposeBase<BT, CUL>, EL>, UL>::RET,
                  ST>::VAL (Standardize<SU, ST>::VAL (_value));}


        ST value (const std::string &symbol)
          {ST value;
           ::unit::Unit<BT> *unitp = PQ::findBySymbol (symbol);

           value = dynamic_reverse<UL>::VAL
                    (Standardize<SU, ST>::VAL (_value), *unitp);

           delete (unitp);

           return value;
          }


        template<class NU>
          Variable<PQ, NU> operator () (const NU &) const 
                               {return Variable<PQ, NU> (_value, SU());}


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


        static std::string Unitsymbol (void) {return SU::Symbol ();}


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


        static std::string Unitname (void) {return SU::Name ();}


        Variable & operator+= (const Variable &variable)
          {if(BSUtilities::IF<BSUtilities::SameType<UL, 
            Loki::Typelist<unit::NonPrefixable<BT, unit::GenericUnit>, 
              Loki::NullType> >::sameType, AssignmentError<true>, 
                                     AssignmentError<false> >::RET::RET)
           _value += variable.value (); 
           return *this;
          }


        template <template<class, class, class> class Q1, 
                                                   class SU1, class DD1>
          Variable & operator+= (const Q1<PQ, SU1, DD1> &quantity)
            {_value = Reverse<SU, ST>::VAL 
              (Standardize<Unit, ST>::VAL (_value) + 
                         Standardize<SU1, ST>::VAL (quantity.value ()));
              return *this;
            }


        template <template<class, class, class> class Q1, class BT1,
                            class DIM1, class DU1, class SU1, class DD1>
          Variable & operator+= (const Q1<Quantity<DIM1, BT1, 
            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
                         Loki::NullType>, DU1, ST>, SU1, DD1> &quantity)
            {_value = Reverse<SU, ST>::VAL 
              (Standardize<Unit, ST>::VAL (_value) + 
                Standardize<typename CheckSecondDimension<
                  Variable<PQ, SU, DD>, Q1<Quantity<DIM1, BT1, 
                    Loki::Typelist<unit::NonPrefixable<BT1, 
                      unit::GenericUnit>, Loki::NullType>, DU1, ST>,
                        SU1, DD1> >::RET::Unit, ST>::VAL 
                                                   (quantity.value ()));
              return *this;
            }


        template<template<class, class, class> class Q1, class PQ1, 
          class SU1, class DD1>
          Variable & operator+= (const Q1<PQ1, SU1, DD1> &quantity)
          {
            static const bool RET = 
              BSUtilities::IF<BSUtilities::SameType<PQ, PQ1>::sameType, 
                DimensionError<false>, DimensionError<true> >::RET::RET;
            return *this;
          }


        Variable & operator-= (const Variable &new_variable)
          {if(BSUtilities::IF<BSUtilities::SameType<UL, 
            Loki::Typelist<unit::NonPrefixable<BT, unit::GenericUnit>, 
              Loki::NullType> >::sameType, AssignmentError<true>, 
                                     AssignmentError<false> >::RET::RET)
           _value -= new_variable.value (); 
           return *this;
          }


        template <template<class, class> class Q1, class SU1>
          Variable & operator-= (const Q1<PQ, SU1> &quantity)
            {_value = Reverse<SU, ST>::VAL 
              (Standardize<Unit, ST>::VAL (_value) - 
                         Standardize<SU1, ST>::VAL (quantity.value ()));
              return *this;
            }


        template <template<class, class> class Q1, class BT1,
                                       class DIM1, class DU1, class SU1>
          Variable & operator-= (const Q1<Quantity<DIM1, BT1, 
            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
                              Loki::NullType>, DU1, ST>, SU1> &quantity)
            {_value = Reverse<SU, ST>::VAL 
              (Standardize<Unit, ST>::VAL (_value) - 
                Standardize<typename CheckSecondDimension<
                  Variable<PQ, SU>, Q1<Quantity<DIM1, BT1, 
                    Loki::Typelist<unit::NonPrefixable<BT1, 
                      unit::GenericUnit>, Loki::NullType>, DU1, ST>,
                        SU1> >::RET::Unit, ST>::VAL 
                                                   (quantity.value ()));
              return *this;
            }


        template<template<class, class> class Q1, class PQ1, class SU1>
          Variable & operator-= (const Q1<PQ1, SU1> &quantity)
          {
            static const bool RET = 
              BSUtilities::IF<BSUtilities::SameType<PQ, PQ1>::sameType, 
                DimensionError<false>, DimensionError<true> >::RET::RET;
            return *this;
          }


        Variable & operator*= (const ST factor)
           {_value *= factor;
             return *this;
           }


        Variable & operator/= (const ST divisor)
           {_value /= divisor;
             return *this;
           }
  

        Variable operator+ (void) const
          {return Variable (*this);}


        Variable operator- (void) const
          {return Variable (*this) *= ST(-1.0);}


        template<class Q>
          struct Plus
            {static Variable<PQ,SU> exec 
                   (const Variable<PQ, SU> &variable, const Q &quantity)
              {Variable<PQ, SU> new_object (variable);
                return new_object += quantity;
              }
            };


      template<template<class, class> class Q1, class DIM1, class BT1, 
        class UL1, class DU1, class SU1>
      struct PlusGenerated
        {static Variable<PQ,SU> exec 
          (const Variable<PQ,SU> &variable, 
             const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> &quantity)
            {return Variable<PQ, SU> (Reverse<SU, ST>::VAL 
              (Standardize<SU, ST>::VAL (variable.value ()) 
                + Standardize<typename CheckSecondDimension<
                  Variable<PQ, SU>, Q1<Quantity<DIM1, BT1, UL1, DU1, 
                    ST>, SU1> >::RET::Unit, ST>::VAL 
                                                  (quantity.value ())));
            }
        };
        

        template <template<class, class> class Q1, class DIM1,
                             class BT1, class UL1, class DU1, class SU1>
          Variable operator+ (const Q1<Quantity<DIM1, BT1, UL1, DU1, 
                                              ST>, SU1> &quantity) const
            {return BSUtilities::IF<BSUtilities::SameType<UL, 
              Loki::Typelist<unit::NonPrefixable<BT, 
                unit::GenericUnit>, Loki::NullType> >::sameType, 
                  typename PlusGenerated<Q1, DIM1, BT1, UL1, 
                    DU1, SU1>::PlusGenerated, 
                  typename Plus<Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, 
                             SU1> >::Plus>::RET::exec (*this, quantity);
            }


        Variable operator+ (const Dynamic<ST> &quantity) const
          {Variable new_variable (quantity);
           return *this + new_variable;
          }


        template<template<class, class> class Q>
          friend Variable operator+ 
            (const Dynamic<ST> &quantity1, 
                  const Q<Quantity<DIM, BT, UL, DU, ST>, SU> &quantity2)
          {Variable new_variable (quantity1);
           return new_variable + quantity2;
          }


        template<class Q>
          struct Minus
            {static Variable<PQ,SU> exec 
                   (const Variable<PQ, SU> &variable, const Q &quantity)
              {Variable<PQ, SU> new_object (variable);
                return new_object -= quantity;
              }
            };


      template<template<class, class> class Q1, class DIM1, class BT1, 
        class UL1, class DU1, class SU1>
      struct MinusGenerated
        {static Variable<PQ,SU> exec 
          (const Variable<PQ,SU> &variable, 
             const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> &quantity)
            {return Variable<PQ, SU> (Reverse<SU, ST>::VAL 
              (Standardize<SU, ST>::VAL (variable.value ()) 
                - Standardize<typename CheckSecondDimension<
                  Variable<PQ, SU>, Q1<Quantity<DIM1, BT1, UL1, DU1, 
                    ST>, SU1> >::RET::Unit, ST>::VAL 
                                                  (quantity.value ())));
            }
        };
        

        template <template<class, class> class Q1, class DIM1,
                             class BT1, class UL1, class DU1, class SU1>
          Variable operator- (const Q1<Quantity<DIM1, BT1, UL1, DU1, 
                                              ST>, SU1> &quantity) const
            {return BSUtilities::IF<BSUtilities::SameType<UL, 
              Loki::Typelist<unit::NonPrefixable<BT, 
                unit::GenericUnit>, Loki::NullType> >::sameType, 
                  typename MinusGenerated<Q1, DIM1, BT1, UL1, 
                    DU1, SU1>::MinusGenerated, 
                  typename Minus<Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, 
                            SU1> >::Minus>::RET::exec (*this, quantity);
            }


        Variable operator- (const Dynamic<ST> &quantity) const
          {Variable new_variable (quantity);
           return *this - new_variable;
          }


        template<template<class, class> class Q>
          friend Variable operator- 
            (const Dynamic<ST> &quantity1, 
                  const Q<Quantity<DIM, BT, UL, DU, ST>, SU> &quantity2)
          {Variable new_variable (quantity1);
           return new_variable - quantity2;
          }


        Variable operator* (const ST factor) const
          {Variable<PQ, SU> new_object (*this);
            return new_object *= factor;
          }


        Variable operator/ (const ST divisor) const
          {Variable<PQ, SU> new_object (*this);
            return new_object /= divisor;
          }


        template <template<class, class> class Q1>
          friend Variable operator* 
            (const ST factor, const Q1<PQ, SU> &variable)
                         {return Variable<PQ, SU> (variable) *= factor;}


        bool operator== (const Variable &rhs_variable) const
                       {return _value == rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator== (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () == rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator== 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () == Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator!= (const Variable &rhs_variable) const
                       {return _value != rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator!= (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () != rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator!= 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () != Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator> (const Variable &rhs_variable) const
                       {return _value > rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator> (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () > rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator> 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () > Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator< (const Variable &rhs_variable) const
                       {return _value < rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator< (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () < rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator< 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () < Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator>= (const Variable &rhs_variable) const
                      {return _value >= rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator>= (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () >= rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator>= 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () >= Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator<= (const Variable &rhs_variable) const
                       {return _value <= rhs_variable.value ();}


        template <template<class, class> class Q1, class SU1>
          bool operator<= (const Q1<PQ, SU1> &rhs_variable) const
            {return standard_value () <= rhs_variable.standard_value ();
            }


        template <template<class, class> class Q1, 
                 class DIM1, class BT1, class UL1, class DU1, class SU1>
          bool operator<= 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                                                    &rhs_variable) const
            {
             return standard_value () <= Standardize<typename 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        template<class Q>
          typename GenerateVariable<Variable, Q>::Add operator* 
                                                (const Q &factor) const
            {
              return typename GenerateVariable<Variable, Q>::Add 
                         (standard_value () * factor.standard_value ());
            }


        template<class Q>
          typename GenerateVariable<Variable, Q>::Sub operator/ 
                                                (const Q &factor) const
            {
              return typename GenerateVariable<Variable, Q>::Sub 
                         (standard_value () / factor.standard_value ());
            }


        friend
          typename GenerateVariable<Variable, Loki::NullType>::Inv 
            operator/ (const ST numerator, const Variable &factor)
          {
            return typename 
              GenerateVariable<Variable, Loki::NullType>::Inv 
                                 (numerator / factor.standard_value ());
          }


        template<long N, long D>
          typename GenerateVariable<Variable, 
                                     BSUtilities::Rational<N, D> >::Mult
                               pow (const BSUtilities::Rational<N, D> &)
          {return ::quantity::pow 
                               (*this, BSUtilities::Rational<N, D> ());}


        template<int I>
          typename GenerateVariable<Variable, 
              BSUtilities::Rational<I, long(1)> >::Mult 
                                        pow (typename Loki::Int2Type<I>)
          {return ::quantity::pow (*this, Loki::Int2Type<I> ());}


    template<class T>
      Dynamic<ST> pow (const T &exp) const
                                {return ::quantity::pow (*this, exp);}


        friend typename 
          GenerateVariable<Variable, BSUtilities::Rational<1, 2> 
                                 >::Mult sqrt (const Variable &variable)
          {
            return typename 
              GenerateVariable<Variable, BSUtilities::Rational<1, 2> 
                        >::Mult (std::sqrt(variable.standard_value ()));
          }


        typename 
          GenerateVariable<Variable, BSUtilities::Rational<1, 2> 
                                               >::Mult sqrt (void) const
          {
            return typename 
              GenerateVariable<Variable, BSUtilities::Rational<1, 2> 
                                 >::Mult (std::sqrt(standard_value ()));
          }


      std::ostream & print_value (std::ostream &os) const
        {return os << _value << " " << SU::Symbol ();}


      void operator>> (std::string &str) const
          {str = BSUtilities::Conversion<Variable>::to_string (*this);}


      std::ostream & operator>> (std::ostream &os) const
                   {return this->print (os);}


      void read_value (const std::string &str);


      friend void operator>> 
        (const std::string &str, Variable &variable) 
                                            {variable.read_value (str);}

      void operator<< (const std::string &str) {read_value (str);}

      void operator= (const std::string &str) {this->read_value (str);}


      std::istream & operator<< (std::istream &is) 
        {std::string string; getline (is, string); 
                                  this->read_value (string); return is;}


      friend std::istream & operator>> 
        (std::istream &is, Variable &variable) {return variable << is;}


    void save (BSUtilities::xmlw::XmlStream &os) const 
    {
      os << BSUtilities::xmlw::tag(TAG)
         << BSUtilities::xmlw::attr (MODETAG) << MODE
         << BSUtilities::xmlw::attr (BASENAMETAG) << Name<ABQ>::String
         << BSUtilities::xmlw::attr (VALUETAG) << _value
         << BSUtilities::xmlw::attr (UNITTAG) << SU::Name ()
         << BSUtilities::xmlw::endtag(TAG);
// to be added ... dedimensionalizer?
    }


    void load (const TiXmlHandle node) const
    {
        TiXmlElement *element = node.Element();

        if (element
          && (element->ValueStr () == Quantities::TAG)
            && (element->Attribute(MODETAG) == MODE))
        {
// to be added ...
        }
        else
          throw LoadError
                 ("error loading variable quantity: incorrect element");
    }


//    PQ (???) * create (void) {return new Variable;}
// to be implemented


      static const std::string MODE;

    };

template<long RL_N, long RL_D, long RM_N, long RM_D, 
  long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D,
    long RA_N, long RA_D, long RLU_N, long RLU_D,  
      class BT, class UL, class DU, class SU, class ST, class R,
                                                   class DDH, class DDT>
  const std::string Variable<Quantity<dimension::Dimension<
    BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >, BT, UL, DU, ST>,
                          SU, Loki::Functor<R, Loki::Typelist<DDH, DDT>
                                                 > >::MODE = "variable";

template<long RL_N, long RL_D, long RM_N, long RM_D, 
  long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D,
    long RA_N, long RA_D, long RLU_N, long RLU_D,  
      class BT, class UL, class DU, class SU, class ST, class R,
                                                   class DDH, class DDT>
const typename Loki::Functor<R, typename Loki::Typelist<DDH, DDT> > 
  Variable<Quantity<dimension::Dimension<
    BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >, BT, UL, DU, ST>,
                          SU, Loki::Functor<R, Loki::Typelist<DDH, DDT>
                                                 > >::_defaultDD = 
       typename Loki::Functor<R, typename Loki::Typelist<DDH, DDT> > 
                                             (defaultDedimensionalizer);

template<long RL_N, long RL_D, long RM_N, long RM_D, 
  long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D,
    long RA_N, long RA_D, long RLU_N, long RLU_D,  
      class BT, class UL, class DU, class SU, class ST, class R,
                                                   class DDH, class DDT>
  void 
    Variable<Quantity<dimension::Dimension<
    BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >, BT, UL, DU, ST>,
                  SU, Loki::Functor<R, Loki::Typelist<DDH, DDT> > >
                                   ::read_value (const std::string &str)
    {
      std::string value;
      std::string unit;

      std::string::size_type start;
      std::string::size_type end;

      start = str.find_first_not_of (" \0");
      end = start;

      if (RS.name ())
      {
        if (start == std::string::npos)
          throw InputError ();

        else
        {
          end = str.find_first_of (" \0", start);

          if (end == std::string::npos)
            namestring = str.substr (start);

          else
            namestring = (str.substr (start, end - start));
        }
      }

      start = str.find_first_not_of (" \0", end);
      end = start;
 
      if (RS.symbol ())
      {
        if (start == std::string::npos)
          throw InputError ();

        else
        {
          end = str.find_first_of (" \0", start);

          if (end == std::string::npos)
            symbolstring = str.substr (start);

          else
            symbolstring = (str.substr (start, end - start));
        }
      }

      start = str.find_first_not_of (" \0", end);
      end = start;

      if (RS.equal () && (RS.name () || RS.symbol ()))
      {
        if (start == std::string::npos)
          throw InputError ();

        else
        {
          end = str.find_first_of (" \0", start);

          if (end == std::string::npos)
            throw InputError ();

          else if (str.substr (start, end - start) != "=")
            throw InputError ();
        }
      }

      start = str.find_first_not_of (" \0", end);
      end = start;
 
      if (start == std::string::npos)
        throw InputError ();

      else
      {
        end = str.find_first_of (" \0", start);

        if (end == std::string::npos)
          value = str.substr (start);

        else
          value = str.substr (start, end - start);

        start = str.find_first_not_of (" \0", end);

        if (start == std::string::npos)
          unit = "";

        else
        {
          end = str.find_first_of (" \0\n", start);

          if (end = std::string::npos)
            unit = str.substr (start);

          else
            unit = str.substr (start, end - start);
        }
      }
   
      ST intermediate;

      try {
        intermediate = BSUtilities::Conversion<ST>::string_to (value);
          }

      catch (BSUtilities::ConversionFailure) {throw InputError ();}

      start = unit.find_first_not_of (" \0");
      end = start;
 
/* if no unit symbol string is present in input, assume one or use
   storage unit
*/
      if (start == std::string::npos)
      {
        std::string assume_unit;

/* if a unit has been set, use this for conversion of intermediate
   (value); else do nothing, since we assume that the value is in 
   the storage unit and can be stored directly. 
*/
        if ((assume_unit = RS.unit ()) != "")
        {
          try {
            ::unit::Unit<BT> *unitp = PQ::findBySymbol (assume_unit);
            intermediate 
              = Reverse<SU, ST>::VAL 
                  (dynamic_standardize<UL>::VAL (intermediate, *unitp));

            delete (unitp);
              }

          catch (UnitMismatch) {throw InputError ();}

        }
      }

/* if unit symbol string is present in input, use it for conversion
   of intermediate (value)
*/
      else
      {
        end = unit.find_first_of (" \0", start);
        try {
          ::unit::Unit<BT> *unitp 
                  = PQ::findBySymbol (unit.substr (start, end - start));

          intermediate 
            = Reverse<SU, ST>::VAL 
                  (dynamic_standardize<UL>::VAL (intermediate, *unitp));

          delete (unitp);
            }
        catch (UnitMismatch) {throw InputError ();}
      }
      

      _value = intermediate;

    }


template<template<class, class, class> class Q1, class BT1, 
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1, 
                                                              class DD1,
         template<class, class, class> class Q2, class BT2, 
          long RL2_N, long RL2_D, long RM2_N, long RM2_D,
             long RT2_N, long RT2_D, long RE2_N, long RE2_D,
               long RTE2_N, long RTE2_D, long RA2_N, long RA2_D,
                 long RLU2_N, long RLU2_D,
                   class UL2, class DU2, class SU2, class DD2, class ST>
  struct GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                                          BT1, UL1, DU1, ST>, SU1, DD1>,
     Q2<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL2_N, RL2_D>,
        BSUtilities::Rational<RM2_N, RM2_D>,
          BSUtilities::Rational<RT2_N, RT2_D>,
            BSUtilities::Rational<RE2_N, RE2_D>,
              BSUtilities::Rational<RTE2_N, RTE2_D>,
                BSUtilities::Rational<RA2_N, RA2_D>,
                  BSUtilities::Rational<RLU2_N, RLU2_D> >,
                                         BT2, UL2, DU2, ST>, SU2, DD2> >
  {
     private:
       typedef typename 
         dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
           BSUtilities::Rational<RM1_N, RM1_D>,
             BSUtilities::Rational<RT1_N, RT1_D>,
               BSUtilities::Rational<RE1_N, RE1_D>,
                 BSUtilities::Rational<RTE1_N, RTE1_D>,
                   BSUtilities::Rational<RA1_N, RA1_D>,
                     BSUtilities::Rational<RLU1_N, RLU1_D> >
         ::template Add<dimension::Dimension<
           BSUtilities::Rational<RL2_N, RL2_D>,
             BSUtilities::Rational<RM2_N, RM2_D>,
               BSUtilities::Rational<RT2_N, RT2_D>,
                 BSUtilities::Rational<RE2_N, RE2_D>,
                   BSUtilities::Rational<RTE2_N, RTE2_D>,
                     BSUtilities::Rational<RA2_N, RA2_D>,
                         BSUtilities::Rational<RLU2_N, RLU2_D> > > AddT;

       typedef unit::NonPrefixable<GenericClass<typename AddT::Res>, 
                                               unit::GenericUnit> AddU;
       typedef Loki::Typelist<AddU, Loki::NullType> AddUnits;
       typedef Quantity<typename AddT::Res, 
          GenericClass<typename AddT::Res>, AddUnits, AddU, ST> AddNewQ;

       typedef typename 
         dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
           BSUtilities::Rational<RM1_N, RM1_D>,
             BSUtilities::Rational<RT1_N, RT1_D>,
               BSUtilities::Rational<RE1_N, RE1_D>,
                 BSUtilities::Rational<RTE1_N, RTE1_D>,
                   BSUtilities::Rational<RA1_N, RA1_D>,
                     BSUtilities::Rational<RLU1_N, RLU1_D> >
         ::template Sub<dimension::Dimension<
           BSUtilities::Rational<RL2_N, RL2_D>,
             BSUtilities::Rational<RM2_N, RM2_D>,
               BSUtilities::Rational<RT2_N, RT2_D>,
                 BSUtilities::Rational<RE2_N, RE2_D>,
                   BSUtilities::Rational<RTE2_N, RTE2_D>,
                     BSUtilities::Rational<RA2_N, RA2_D>,
                         BSUtilities::Rational<RLU2_N, RLU2_D> > > SubT;

       typedef unit::NonPrefixable<GenericClass<typename SubT::Res>,
                                               unit::GenericUnit> SubU;
       typedef Loki::Typelist<SubU, Loki::NullType> SubUnits;
       typedef Quantity<typename SubT::Res, 
          GenericClass<typename SubT::Res>, SubUnits, SubU, ST> SubNewQ;

     public:
       typedef Variable<AddNewQ, AddU> Add;
       typedef Variable<SubNewQ, SubU> Sub;
  };


template<template<class, class, class> class Q1, class BT1, 
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, 
                  class UL1, class DU1, class SU1, class DD1, class ST1>
  struct GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                         BT1, UL1, DU1, ST1>, SU1, DD1>, Loki::NullType>
  {
     private:
       typedef typename 
         dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
           BSUtilities::Rational<RM1_N, RM1_D>,
             BSUtilities::Rational<RT1_N, RT1_D>,
               BSUtilities::Rational<RE1_N, RE1_D>,
                 BSUtilities::Rational<RTE1_N, RTE1_D>,
                   BSUtilities::Rational<RA1_N, RA1_D>,
                      BSUtilities::Rational<RLU1_N, RLU1_D> >::Inv InvT;

       typedef unit::NonPrefixable<GenericClass<typename InvT::Res>, 
                                               unit::GenericUnit> InvU;
       typedef Loki::Typelist<InvU, Loki::NullType> InvUnits;
       typedef Quantity< typename InvT::Res, 
         GenericClass<typename InvT::Res>, InvUnits, InvU, ST1> InvNewQ;

     public:
       typedef Variable<InvNewQ, InvU> Inv;
  };


template<template<class, class, class> class Q1, class BT1, 
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, class UL1, class DU1, class DD1, 
                                   class ST1, class SU1, long N, long D>
  struct GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1>, 
                                           BSUtilities::Rational<N, D> >
  {
     private:
       typedef typename 
         dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
           BSUtilities::Rational<RM1_N, RM1_D>,
             BSUtilities::Rational<RT1_N, RT1_D>,
               BSUtilities::Rational<RE1_N, RE1_D>,
                 BSUtilities::Rational<RTE1_N, RTE1_D>,
                   BSUtilities::Rational<RA1_N, RA1_D>,
                     BSUtilities::Rational<RLU1_N, RLU1_D> >::template 
                                                       Mult<N, D> MultT;

       typedef unit::NonPrefixable<GenericClass<typename MultT::Res>,
                                              unit::GenericUnit> MultU;
       typedef Loki::Typelist<MultU, Loki::NullType> MultUnits;
       typedef Quantity<typename MultT::Res, 
         GenericClass<typename MultT::Res>, MultUnits, MultU, ST1> 
                                                               MultNewQ;

     public:
       typedef Variable<MultNewQ, MultU> Mult;
  };


template<template<class, class, class> class Q1, class BT1, 
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, 
           class UL1, class DU1, class ST1, class SU1, class DD1, int I>
  inline typename GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1>, 
              BSUtilities::Rational<I, long(1)> >::Mult 
                pow (const 
    Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1> &quantity, 
                                             typename Loki::Int2Type<I>)
          {
            return typename 
              GenerateVariable<
    Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1>, 
                         BSUtilities::Rational<long(I), long(1)> >::Mult
                              (std::pow(quantity.standard_value (), I));
          }


template<template<class, class, class> class Q1, class BT1, 
  long RL1_N, long RL1_D, long RM1_N, long RM1_D,
    long RT1_N, long RT1_D, long RE1_N, long RE1_D,
      long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
        long RLU1_N, long RLU1_D, 
          class UL1, class DU1, class ST1, class SU1, class DD1, 
                                                         long N, long D>
  inline typename GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1>, 
              BSUtilities::Rational<N, D> >::Mult 
                pow (const 
    Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1> &quantity, 
                                    const BSUtilities::Rational<N, D> &)
          { return typename 
              GenerateVariable
    <Q1<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST1>, SU1, DD1>, 
                                     BSUtilities::Rational<N, D> >::Mult
               (std::pow(quantity.standard_value (), 
                        static_cast<double>(N)/static_cast<double>(D)));
          }


template<template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                       class UL, class DU, class ST, class SU, class DD>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
  abs (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                     BT, UL, DU, ST>, SU, DD> &variable)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
                                        (std::abs (variable.value ()));}


template<template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                       class UL, class DU, class ST, class SU, class DD>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
  ceil (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                     BT, UL, DU, ST>, SU, DD> &variable)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
                                       (std::ceil (variable.value ()));}


template<template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                       class UL, class DU, class ST, class SU, class DD>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
  floor (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                     BT, UL, DU, ST>, SU, DD> &variable)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
                                      (std::floor (variable.value ()));}


template<template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                       class UL, class DU, class ST, class SU, class DD>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
  frexp (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                      BT, UL, DU, ST>, SU, DD> &variable, int *exponent)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
                            (std::frexp (variable.value (), exponent));}


template<template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                       class UL, class DU, class ST, class SU, class DD>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
  ldexp (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                       BT, UL, DU, ST>, SU, DD> &variable, int exponent)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                BT, UL, DU, ST>, SU, DD>
                            (std::ldexp (variable.value (), exponent));}


template<template<class, class, class> class Q, 
  template<class, class, class> class Q1, class BT, 
    long RL_N, long RL_D, long RM_N, long RM_D,
      long RT_N, long RT_D, long RE_N, long RE_D,
        long RTE_N, long RTE_D, long RA_N, long RA_D,
          long RLU_N, long RLU_D, 
           class UL, class DU, class ST, class SU, class DD1, class DD2>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
  fmod (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                   BT, UL, DU, ST>, SU, DD1> &quantity1,
        const Q1<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                   BT, UL, DU, ST>, SU, DD2> &quantity2)
    {return 
      Variable<Quantity<
        dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
          BSUtilities::Rational<RM_N, RM_D>,
            BSUtilities::Rational<RT_N, RT_D>,
              BSUtilities::Rational<RE_N, RE_D>,
                BSUtilities::Rational<RTE_N, RTE_D>,
                  BSUtilities::Rational<RA_N, RA_D>,
                    BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
      (std::fmod (quantity1.value (), quantity2.value ()));
    }


template<template<class, class, class> class Q, 
  template<class, class, class> class Q1, class BT, 
    long RL_N, long RL_D, long RM_N, long RM_D,
      long RT_N, long RT_D, long RE_N, long RE_D,
        long RTE_N, long RTE_D, long RA_N, long RA_D,
          long RLU_N, long RLU_D, 
            class UL, class DU, class ST, class SU, class SU1, 
                                                   class DD1, class DD2>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
  fmod (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                   BT, UL, DU, ST>, SU, DD1> &quantity1,
        const Q1<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                  BT, UL, DU, ST>, SU1, DD2> &quantity2)
  {return 
    Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>,
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
    (Reverse<SU, ST>::VAL 
      (std::fmod (quantity1.standard_value (), 
                                         quantity2.standard_value ())));
  }


template <template<class, class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, class UL, class DU, class ST, class SU, 
          class DD1,
  template<class, class, class> class Q1, class BT1, 
    long RL1_N, long RL1_D, long RM1_N, long RM1_D,
      long RT1_N, long RT1_D, long RE1_N, long RE1_D,
        long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
          long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1, 
                                                              class DD2>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
  fmod (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                   BT, UL, DU, ST>, SU, DD1> &quantity1,
        const Q1<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
      BSUtilities::Rational<RM1_N, RM1_D>,
        BSUtilities::Rational<RT1_N, RT1_D>,
          BSUtilities::Rational<RE1_N, RE1_D>,
            BSUtilities::Rational<RTE1_N, RTE1_D>,
              BSUtilities::Rational<RA1_N, RA1_D>,
                BSUtilities::Rational<RLU1_N, RLU1_D> >,
                               BT1, UL1, DU1, ST>, SU1, DD2> &quantity2)
  {return Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                               BT, UL, DU, ST>, SU, DD1>
    (Reverse<SU, ST>::VAL (std::fmod (quantity1.standard_value (),
      Standardize<typename CheckSecondDimension<
        Variable<Quantity<
          dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
            BSUtilities::Rational<RM_N, RM_D>,
              BSUtilities::Rational<RT_N, RT_D>,
                BSUtilities::Rational<RE_N, RE_D>,
                  BSUtilities::Rational<RTE_N, RTE_D>,
                    BSUtilities::Rational<RA_N, RA_D>,
                      BSUtilities::Rational<RLU_N, RLU_D> >,
                                              BT, UL, DU, ST>, SU, DD1>,
        Q1<Quantity<
          dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
            BSUtilities::Rational<RM1_N, RM1_D>,
              BSUtilities::Rational<RT1_N, RT1_D>,
                BSUtilities::Rational<RE1_N, RE1_D>,
                  BSUtilities::Rational<RTE1_N, RTE1_D>,
                    BSUtilities::Rational<RA1_N, RA1_D>,
                      BSUtilities::Rational<RLU1_N, RLU1_D> >,
                    BT1, UL1, DU1, ST>, SU1, DD2> >::RET::Unit, ST>::VAL
                                                (quantity2.value ()))));
  }


template<template<class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
         long RLU_N, long RLU_D, class UL, class DU, class ST, class SU>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                    BT, UL, DU, ST>, SU>
  modf (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                         BT, UL, DU, ST>, SU> &quantity,
  Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                         BT, UL, DU, ST>, SU> *integral)
  {ST i_ptr; 
    Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>,
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >,
                                                    BT, UL, DU, ST>, SU>
                   new_variable (std::modf (quantity.value (), &i_ptr));
    Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>,
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >,
                              BT, UL, DU, ST>, SU> int_quantity (i_ptr);
                          *integral = int_quantity; return new_variable;
        }


template<template<class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                      class UL, class DU, class ST, class SU, class SU1>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                    BT, UL, DU, ST>, SU>
  modf (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                         BT, UL, DU, ST>, SU> &quantity,
  Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                        BT, UL, DU, ST>, SU1> *integral)
  {ST i_ptr; 
    Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>,
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >,
                                                    BT, UL, DU, ST>, SU>
                   new_variable (std::modf (quantity.value (), &i_ptr));
  Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                      BT, UL, DU, ST>, SU1> int_quantity (i_ptr, SU ());
                          *integral = int_quantity; return new_variable;
        }


template<template<class, class> class Q, class BT, 
  long RL_N, long RL_D, long RM_N, long RM_D,
    long RT_N, long RT_D, long RE_N, long RE_D,
      long RTE_N, long RTE_D, long RA_N, long RA_D,
        long RLU_N, long RLU_D, 
                      class UL, class DU, class ST, class SU, class SU1,
  class BT1, 
    long RL1_N, long RL1_D, long RM1_N, long RM1_D,
      long RT1_N, long RT1_D, long RE1_N, long RE1_D,
        long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
                         long RLU1_N, long RLU1_D, class UL1, class DU1>
  inline Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                                    BT, UL, DU, ST>, SU>
  modf (const Q<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
      BSUtilities::Rational<RM_N, RM_D>,
        BSUtilities::Rational<RT_N, RT_D>,
          BSUtilities::Rational<RE_N, RE_D>,
            BSUtilities::Rational<RTE_N, RTE_D>,
              BSUtilities::Rational<RA_N, RA_D>,
                BSUtilities::Rational<RLU_N, RLU_D> >,
                                         BT, UL, DU, ST>, SU> &quantity,
  Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
      BSUtilities::Rational<RM1_N, RM1_D>,
        BSUtilities::Rational<RT1_N, RT1_D>,
          BSUtilities::Rational<RE1_N, RE1_D>,
            BSUtilities::Rational<RTE1_N, RTE1_D>,
              BSUtilities::Rational<RA1_N, RA1_D>,
                BSUtilities::Rational<RLU1_N, RLU1_D> >,
                                     BT1, UL1, DU1, ST>, SU1> *integral)
  {ST i_ptr; 
    typename CheckSecondDimension<Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                  BSUtilities::Rational<RLU1_N, RLU1_D> >,
                                               BT1, UL1, DU1, ST>, SU1>,
    Variable<Quantity<
      dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
        BSUtilities::Rational<RM_N, RM_D>,
          BSUtilities::Rational<RT_N, RT_D>,
            BSUtilities::Rational<RE_N, RE_D>,
              BSUtilities::Rational<RTE_N, RTE_D>,
                BSUtilities::Rational<RA_N, RA_D>,
                  BSUtilities::Rational<RLU_N, RLU_D> >,
                                             BT, UL, DU, ST>, SU> >::RET
         new_variable (Reverse<SU, ST>::VAL 
                      (std::modf (quantity.standard_value (), &i_ptr)));
  *integral = Variable<Quantity<
    dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
      BSUtilities::Rational<RM1_N, RM1_D>,
        BSUtilities::Rational<RT1_N, RT1_D>,
          BSUtilities::Rational<RE1_N, RE1_D>,
            BSUtilities::Rational<RTE1_N, RTE1_D>,
              BSUtilities::Rational<RA1_N, RA1_D>,
                BSUtilities::Rational<RLU1_N, RLU1_D> >,
                  BT1, UL1, DU1, ST>, SU1> 
                                        (Reverse<SU1, ST>::VAL (i_ptr));
  return new_variable;
  }

}

#endif /* _Variable_h */

---