Variable.h

Go to the documentation of this file.

/* 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 _Variable_h
#define _Variable_h

// Quantity includes
#include "Quantities/Quantity/Quantity.h"
#include "Quantities/Quantity/QuantityError.h"
#include "Quantities/Quantity/Generic.h"
#include "Quantities/Quantity/Dynamic.h"

// Loki includes
#include "loki/Typelist.h"
#include "loki/NullType.h"
#include "loki/HierarchyGenerators.h"

// BOOST includes
#include <boost/serialization/base_object.hpp>

namespace quantity {

//  Helper classes and structs for compiling error messages


template<bool> 
  struct VariableError;


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<template<typename, typename> class Q1, typename QT1,
                                      typename DQT1, typename ST1,
         template<typename, typename> class Q2, typename QT2, 
                                     typename DQT2, typename ST2> 
  struct SameDimensioned 
        <Q1<Quantity<QT1, ST1>, DQT1>, Q2<Quantity<QT2, ST2>, DQT2> >
  {
    enum {EQ = SameDimensioned<Quantity<QT1, ST1>, Quantity<QT2, ST2> >::EQ};
  };



template<class Q1, class Q2> struct CheckSecondDimension;

template<template<typename, typename> class Q1, typename QT1, 
                                        typename DQT1, typename ST1, 
         template<typename, typename> class Q2, class QT2, 
                                            typename DQT2, typename ST2>
  struct CheckSecondDimension
         <Q1<Quantity<QT1, ST1>, DQT1>, Q2<Quantity<QT2, ST2>, DQT2> >
  {
    public: 
      typedef typename 
        BSUtilities::IF<SameDimensioned<Quantity<QT1, ST1>, Quantity<QT2, ST2> 
          >::EQ, Q2<Quantity<QT2, ST2>, DQT2>, DimensionError<true> >::RET RET;
  };

//
//  construction helpers for Variable 
//


    template<typename QT, typename DQT>
        struct OverwriteNameString
        {static std::string exec (void)
          {return DerivedQuantityTraits<QT, DQT>::NameString ();}
        };


    template<typename QT>
        struct UseNameString
        {static std::string exec (void)
          {return QuantityTraits<QT>::NameString ();}
        };


    template<typename QT, typename DQT>
        struct Name
        {static std::string exec (void)
          {return BSUtilities::IF<DerivedQuantityTraits<QT, DQT>::OverwriteName, 
             OverwriteNameString<QT, DQT>, UseNameString<QT> >::RET::exec();}
        };


    template<typename QT, typename DQT>
        struct OverwriteSymbolString
        {static std::string exec (void)
          {return DerivedQuantityTraits<QT, DQT>::SymbolString ();}
        };


    template<typename QT>
        struct UseSymbolString
        {static std::string exec (void)
            {return QuantityTraits<QT>::SymbolString ();}
        };


    template<typename QT, typename DQT>
        struct Symbol
        {static std::string exec (void)
          {return BSUtilities::IF<DerivedQuantityTraits<QT, DQT>::OverwriteSymbol, 
              OverwriteSymbolString<QT, DQT>, UseSymbolString<QT> >::RET::exec();}
        };

//
//  forward declarations
//


template<typename Q1, typename Q2> struct GenerateVariable;

//
//  the Variable classes
//


template<typename BQ, typename DQ = DerivedQuantity<typename BQ::QT, 
            typename BQ::DU, typename BQ::DDQ> > class Variable;


template<typename QT, typename ST, typename DQSU, typename DQT>
  class Variable<Quantity<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > 
                                             : public Quantity<QT, ST>
    {
      public:

        typedef typename QuantityTraits<QT>::Dimension DIM;


        typedef typename QuantityTraits<QT>::UnitType UT;


        typedef typename QuantityTraits<QT>::UnitList UL;


        typedef Quantity<QT, ST> BQ;


        typedef typename BQ::DU DU;


        typedef typename unit::ValidUnit<DQSU, UL>::RET SU;


        typedef Variable<BQ, DerivedQuantity<QT, SU, DQT> > V;

      private:

        ST _value;

//  constructors for Variable 

      public:

        Variable (void) : BQ (), _value (ST(0)) 
          {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());}


        Variable (const ST &value) : BQ (), _value (value)
          {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());}


        Variable (const ST &value, const std::string &namestring, 
          const std::string &symbolstring) : BQ (), _value (value)
          {BQ::name (namestring); BQ::symbol (symbolstring);}


        template<typename NU>
          Variable (const ST &value, const NU &) 
            : BQ (), _value (unit::Reverse<SU>::VAL 
              (unit::Standard<typename unit::ValidUnit<NU, UL>::RET>::VAL
                                                                       (value)))
            {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());}


        template<typename NU>
          Variable (const ST &value, const NU &, 
                 const std::string &namestring, const std::string &symbolstring)
            : BQ (), _value (unit::Reverse<SU>::VAL 
             (unit::Standard<typename unit::ValidUnit<NU, UL>::RET>::VAL 
                                                                       (value)))
            {BQ::name (namestring); BQ::symbol (symbolstring);}


        Variable (const ST value, const std::string &unitsymbol) : BQ ()
          {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());
            _value = unit::Reverse<SU>::VAL
               (unit::standard<UL>::VAL (value, unitsymbol));
          }


        Variable (const ST value, const char * unitsymbol) : BQ ()
          {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());
            _value = unit::Reverse<SU>::VAL
               (unit::standard<UL>::VAL (value, std::string (unitsymbol)));
            }

//  end constructors for Variable 

//  copy constructors for Variable 


        template<template<typename, typename> class SM, typename SST>
          Variable (const SM<Quantity<QT, SST>, DQT> &quantity) 
            : BQ (), _value (quantity.value ())
              {name (quantity.BQ::name ()); symbol (quantity.BQ::symbol ());}
 

        template<template<typename, typename> class SM, 
                                    typename SST, typename SSU, typename SDQT>
          Variable (const SM<Quantity<QT, SST>, 
                                  DerivedQuantity<QT, SSU, SDQT> > &quantity)
            : BQ (), _value (unit::Reverse<SU>::VAL 
              (unit::Standard<SSU>::VAL (quantity.value ())))
              {name (quantity.Quantity<QT, SST>::name ()); 
                  symbol (quantity.Quantity<QT, SST>::symbol ());}


        template<template<typename, typename> class SM, 
                 typename SDIM, typename SST, typename SSU, typename SDQT>
          Variable (const SM<Quantity<GenericClass<SDIM>, SST>, 
            DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > &quantity)
            : BQ (), _value (unit::Reverse<SU>::VAL
              (unit::Standard<typename
                 CheckSecondDimension<V, 
                   SM<Quantity<GenericClass<SDIM>, SST>, 
                     DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > >
                       ::RET::SU>::VAL (quantity.value ())))
              {name (quantity.Quantity<GenericClass<SDIM>, SST>::name ()); 
                   symbol (quantity.Quantity<GenericClass<SDIM>, SST>::symbol ());}


        template<template<typename, typename> class SM, 
                      typename SQT, typename SST, typename SSU, typename SDQT>
          Variable (const SM<Quantity<SQT, SST>, 
                                   DerivedQuantity<SQT, SSU, SDQT> > &quantity)
            : BQ (), _value (convertValue<V, SM<Quantity<SQT, SST>, 
              DerivedQuantity<SQT, SSU, SDQT> > >::exec (quantity))
              {name (quantity.Quantity<SQT, SST>::name ()); 
                  symbol (quantity.Quantity<SQT, SST>::symbol ());}



        template<typename SST>
          Variable (const Dynamic<SST> &dynamic)
            {if (dynamic.isCommensurable (*this))
               _value = unit::Reverse<SU>::VAL (dynamic.value ());
             else
               {throw DimensionMismatch ();}

            }

//  end copy constructors for Variable 

//  assignment operators for Variable 


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


        template<template<typename, typename> class SM, typename SST, 
          typename SSU, typename SDQT>
          Variable & operator= (const SM<Quantity<QT, SST>, 
                                     DerivedQuantity<QT, SSU, SDQT> > &quantity)
          {_value = unit::Reverse<SU>::VAL (unit::Standard<SSU>::VAL 
                                                           (quantity.value ()));
           return *this;
          }


        template<typename SDIM, typename SST, typename SSU, typename SDQT>
          Variable & operator= 
            (const Variable<Quantity<GenericClass<SDIM>, SST>, 
               DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > &quantity)
            {_value = unit::Reverse<SU>::VAL
               (unit::Standard<typename
                 CheckSecondDimension<V, 
                              Variable<Quantity<GenericClass<SDIM>, SST>, 
                   DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > >
                      ::RET::SU>::VAL (quantity.value ()));
             return *this;
            }


        template<template<typename, typename> class SM, 
                          typename SQT, typename SST, typename SSU, typename SDQT>
          Variable & operator= 
            (const SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > &quantity)
          {*this = V(quantity);
           return *this;
          }


      template<typename SST>
        Variable & operator= (const Dynamic<SST> &dynamic)
          {if (dynamic.isCommensurable (*this))
             _value = unit::Reverse<SU>::VAL (dynamic.value ());
           else
             {throw DimensionMismatch ();}
           return *this;
          }


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


      Variable & operator= (const char * str) {this->read_value (str); return *this;}


    template <typename T>
      Variable & operator= (const T &);

//  end assignment operators for Variable 

//  state reporting member functions for Variable 

    public:

        ST value (void) const {return _value;}


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


        template<typename NU>
          Variable<Quantity<QT, ST>, 
                     DerivedQuantity<QT, NU, DQT> > value (const NU &) const
            {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> > 
                (unit::Reverse<typename unit::ValidUnit<NU, UL>::RET>::VAL
                                 (unit::Standard<SU>::VAL (_value)));}


        ST value (const std::string &unitsymbol)
          {ST value;
           value = unit::reverse<UL>::VAL
                          (unit::Standard<SU>::VAL (_value), unitsymbol);
           return value;
          }

        static std::string QuantityName (void) 
          {return Name<QT, DQT>::exec ();}


        ST value (const char * unitsymbol)
          {return value (std::string (unitsymbol));}


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


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


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


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

//  end state reporting operators for Variable 

//  arithmetic operators for Variable 


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


        template <template<typename, typename> class M1, typename ST1, 
                                                typename SU1, typename DQT1>
          Variable & operator+= (const M1<Quantity<QT, ST1>, 
                                    DerivedQuantity<QT, SU1, DQT1> > &quantity)
            {_value = unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (_value) + 
                 unit::Standard<SU1>::VAL (quantity.value ()));
              return *this;
            }


        template <template<typename, typename> class M1, 
                                    typename DIM1, typename ST1, typename SU1, typename DQT1>
          Variable & operator+= (const M1<Quantity<GenericClass<DIM1>, ST1>,
                               DerivedQuantity<GenericClass<DIM1>, SU1, DQT1> > &quantity)
            {_value = unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (_value) + 
                unit::Standard<typename CheckSecondDimension<V, 
                  M1<Quantity<GenericClass<DIM1>, ST1>, 
                    DerivedQuantity<GenericClass<DIM1>, SU1, DQT1> > >
                          ::RET::SU>::VAL (quantity.value ()));
              return *this;
            }


        template<template<typename, typename> class M1, 
                                 typename QT1, typename ST1, typename SU1, typename DQT1>
          Variable & operator+= (const M1<Variable<QT1, ST1>, 
                                    DerivedQuantity<QT1, SU1, DQT1> > &quantity)
          {
            static const bool RET = 
              BSUtilities::IF<BSUtilities::SameType<QT, QT1>::sameType, 
                DimensionError<false>, DimensionError<true> >::RET::RET;
            return *this;
          }


      template<template<typename, typename> class M1, 
                     typename QT1, typename ST1, typename SU1, typename DQT1>
      struct PlusGenerated
        {static V exec 
          (const V &variable, 
             const M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > &quantity)
            {return V (unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (variable.value ()) 
                + unit::Standard<typename CheckSecondDimension<
                  V, M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > >
                           ::RET::SU>::VAL (quantity.value ())));
            }
        };
        

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


        template <template<typename, typename> class M1, 
                 typename QT1, typename ST1, typename SU1, typename DQT1>
          Variable operator+ (const M1<Quantity<QT1, ST1>, 
                         DerivedQuantity<QT1, SU1, DQT1> > &quantity) const
            {return BSUtilities::IF<BSUtilities::SameType<UL, 
              Loki::Typelist<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                unit::GenericUnit>, Loki::NullType> >::sameType, 
                  typename PlusGenerated<M1, QT1, ST1, SU1, DQT1>::PlusGenerated, 
                    typename Plus<M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > >
                                      ::Plus>::RET::exec (*this, quantity);
            }


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


        template<template<typename, typename> class M1, typename ST1>
          friend Variable operator+ 
            (const Dynamic<ST1> &quantity1, 
                      const M1<BQ, DerivedQuantity<QT, SU, DQT> > &quantity2)
          {Variable new_variable (quantity1);
           return new_variable + quantity2;
          }


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


        template <template<typename, typename> class M1, typename ST1, 
                                             typename SU1, typename DQT1>
          Variable & operator-= (const M1<Quantity<QT, ST1>, 
                                     DerivedQuantity<QT, SU1, DQT1> > &quantity)
            {_value = unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (_value) - 
                unit::Standard<SU1>::VAL (quantity.value ()));
              return *this;
            }


        template <template<typename, typename> class M1, 
                            typename DIM1, typename ST1, typename SU1, typename DQT1>
          Variable & operator-= 
               (const M1<Quantity<GenericClass<DIM1>, ST1>, 
                             DerivedQuantity<GenericClass<DIM1>, SU1, DQT1> > &quantity)
            {_value = unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (_value) - 
                unit::Standard<typename CheckSecondDimension<
                  V, M1<Quantity<GenericClass<DIM1>, ST1>,
                    DerivedQuantity<GenericClass<DIM1>, SU1, DQT1> > >
                        ::RET::SU>::VAL (quantity.value ()));
              return *this;
            }


        template<template<typename, typename> class M1, 
                         typename QT1, typename ST1, typename SU1, typename DQT1>
          Variable & operator-= (const M1<Quantity<QT1, ST1>, 
                                 DerivedQuantity<QT1, SU1, DQT1> > &quantity)
          {
            static const bool RET = 
              BSUtilities::IF<BSUtilities::SameType<QT, QT1>::sameType, 
                DimensionError<false>, DimensionError<true> >::RET::RET;
            return *this;
          }


      template<template<typename, typename> class M1, 
                              typename QT1, typename ST1, typename SU1, typename DQT1>
      struct MinusGenerated
        {static V exec (const V &variable, 
             const M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > &quantity)
            {return V (unit::Reverse<SU>::VAL 
              (unit::Standard<SU>::VAL (variable.value ()) 
                - unit::Standard<typename CheckSecondDimension<
                 V, M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > >
                            ::RET::SU>::VAL (quantity.value ())));
            }
        };
        

        template<typename Q>
          struct Minus
            {static V exec (const V &variable, const Q &quantity)
              {V new_object (variable);
                return new_object -= quantity;
              }
            };


        template <template<typename, typename> class M1, 
                              typename QT1, typename ST1, typename SU1, typename DQT1>
          Variable operator- (const M1<Quantity<QT1, ST1>, 
                                    DerivedQuantity<QT1, SU1, DQT1> > &quantity) const
            {return BSUtilities::IF<BSUtilities::SameType<UL, 
              Loki::Typelist<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                unit::GenericUnit>, Loki::NullType> >::sameType, 
                  typename MinusGenerated<M1, QT1, ST1, SU1, DQT1>::MinusGenerated, 
                  typename Minus<M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > >
                                        ::Minus>::RET::exec (*this, quantity);
            }


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


        template<template<typename, typename> class M1, typename ST1>
          friend Variable operator- 
            (const Dynamic<ST1> &quantity1, 
                     const M1<BQ, DerivedQuantity<QT, SU, DQT> > &quantity2)
          {Variable new_variable (quantity1);
           return new_variable - quantity2;
          }


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


        Variable operator* (const ST factor) const
          {V new_object (*this);
            return new_object *= factor;
          }


      template<typename RHSST>
        Dynamic<RHSST> operator * (const Dynamic<RHSST> &rhs) const
        {return rhs * (*this);}


        template <template<typename, typename> class Q>
          friend V operator* 
            (const ST factor, const Q<Quantity<QT, ST>, 
               DerivedQuantity<QT, SU, DQT> > &variable)
                         {return V (variable) *= factor;}


        template<template<typename, typename> class FM, typename FQT, typename FST, typename FSU,
                                                                           typename FDQT>
          typename GenerateVariable<V, 
            FM<Quantity<FQT, FST>, DerivedQuantity<FQT, FSU, FDQT> > >::Add 
            operator* (const FM<Quantity<FQT, FST>, DerivedQuantity<FQT, FSU, FDQT> > &factor) const
            {
              return typename 
                GenerateVariable<V, FM<Quantity<FQT, FST>, DerivedQuantity<FQT, FSU, FDQT> > >::Add 
                                            (standard_value () * factor.standard_value ());
            }


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

        Variable operator/ (const ST divisor) const
          {V new_object (*this);
            return new_object /= divisor;
          }


        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 ());
          }


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


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


        Variable & operator++ ()
          {++_value;
           return *this;
          }


        Variable & operator-- ()
          {--_value;
           return *this;
          }


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


        const Variable operator-- (int)
          {Variable temp (*this);
           --*this;
           return temp;
          }

//  end arithmetic operators for Variable 

//  comparison operators for Variable 


#define QUANTITY_COMPARISON_OPERATORS(mode, opName, opType) \
  bool opName (const mode &rhs) const \
    {return _value opType rhs.value ();} \
  template <template<typename, typename> class RM, typename RST, typename RSU, typename RDQT> \
    bool opName (const RM<Quantity<QT, RST>, DerivedQuantity<QT, RSU, RDQT> > &rhs) const \
      {return standard_value () opType rhs.standard_value ();} \
  template <template<typename, typename> class RM, \
                                 typename RQT, typename RST, typename RSU, typename RDQT> \
    bool opName (const RM<Quantity<RQT, RST>, DerivedQuantity<RQT, RSU, RDQT> > &rhs) const \
      {return (*this opType V(rhs));} \
  bool opName (const Dynamic<ST> &dynamic) const \
    {if (dynamic.isCommensurable (*this)) \
       return standard_value () opType dynamic.value (); \
     else \
       {throw DimensionMismatch ();} }

QUANTITY_COMPARISON_OPERATORS(Variable, operator==, ==)
QUANTITY_COMPARISON_OPERATORS(Variable, operator!=, !=)
QUANTITY_COMPARISON_OPERATORS(Variable, operator>, >)
QUANTITY_COMPARISON_OPERATORS(Variable, operator<, <)
QUANTITY_COMPARISON_OPERATORS(Variable, operator>=, >=)
QUANTITY_COMPARISON_OPERATORS(Variable, operator<=, <=)

//  end comparison operators for Variable 

//  mathematical functions for Variable 


        template<long N, long D>
          typename GenerateVariable<Variable, 
                                     BSUtilities::Rational<N, D> >::Mult
                         pow (const BSUtilities::Rational<N, D> &) const
          {return std::pow (standard_value (), 
                        static_cast<double>(N)/static_cast<double>(D));}


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


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


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

//  end mathematical functions for Variable 

//  io functions for Variable 


      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);}


      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;}

//  end io functions for Variable 

//  serialization of Variable 

  private:
      friend class boost::serialization::access;


      template<typename Archive>
        void serialize (Archive &ar, const unsigned int )
        {
          ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(BQ);
          ar & BOOST_SERIALIZATION_NVP(_value);
        }

//  end serialization of Variable 

    };

//  end Variable 

template<typename QT, typename ST, typename SU, typename DQT>
  void Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >::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)
            BQ::namestring = str.substr (start);

          else
            BQ::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)
            BQ::symbolstring = str.substr (start);

          else
            BQ::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 {
            intermediate = unit::Reverse<SU>::VAL
               (unit::standard<UL>::VAL (intermediate, assume_unit));
              }

          catch (unit::UnitMismatch) {throw InputError ();}
          catch (unit::UnitSyntaxError) {throw InputError ();}

        }
      }

/* if unit symbol string is present in input, use it for conversion
   of intermediate (value); assume that the rest of the input is 
   unit symbol.
*/
      else
      {
        end = unit.find_first_of (" \0", start);
        try {
            intermediate = unit::Reverse<SU>::VAL
               (unit::standard<UL>::VAL (intermediate, unit.substr (start)));
            }
        catch (unit::UnitMismatch) {throw InputError ();}
        catch (unit::UnitSyntaxError) {throw InputError ();}
      }

      _value = intermediate;

    }


template<template<typename, typename> class Q1, typename QT1, typename DQT1, 
         template<typename, typename> class Q2, typename QT2, typename DQT2,
                                                               typename ST>
  struct GenerateVariable
               <Q1<Quantity<QT1, ST>, DQT1>, Q2<Quantity<QT2, ST>, DQT2> >
  {
     private:
       typedef typename QuantityTraits<QT1>::Dimension Dim1;
       typedef typename QuantityTraits<QT2>::Dimension Dim2;

       typedef typename Dim1::template Add<Dim2> AddT;
       typedef Quantity<GenericClass<typename AddT::Res>, ST> AddNewQ;

       typedef typename Dim1::template Sub<Dim2> SubT;
       typedef Quantity<GenericClass<typename SubT::Res>, ST> SubNewQ;

     public:

       typedef Variable<AddNewQ> Add;


       typedef Variable<SubNewQ> Sub;
  };


template<template<typename, typename> class Q, 
                               typename QT, typename ST, typename DQT>
  struct GenerateVariable <Q<Quantity<QT, ST>, DQT>, Loki::NullType>
  {
     private:
       typedef typename QuantityTraits<QT>::Dimension::Inv InvT;
       typedef Quantity<GenericClass<typename InvT::Res>, ST> InvNewQ;

     public:

       typedef Variable<InvNewQ> Inv;
  };


template<template<typename, typename> class Q, typename QT, 
                                   class ST, class DQT, long N, long D>
  struct GenerateVariable
    <Q<Quantity<QT, ST>, DQT>, BSUtilities::Rational<N, D> >
  {
     private:
       typedef typename QuantityTraits<QT>::Dimension::template
                                                       Mult<N, D> MultT;

       typedef Quantity<GenericClass<typename MultT::Res>, ST> MultNewQ;

     public:

       typedef Variable<MultNewQ> Mult;
  };


template<template<typename, typename> class Q, typename QT, 
           typename ST, typename SU, typename DQT>
  inline typename GenerateVariable
    <Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >, BSUtilities::Rational<1, 2> >::Mult 
      sqrt (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity)
          {
            return typename 
              GenerateVariable<Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >,
                BSUtilities::Rational<1, 2> >::Mult (quantity.sqrt());
          }


template<template<typename, typename> class Q, typename QT, 
                                      typename ST, typename SU, typename DQT, int I>
  inline typename GenerateVariable
    <Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >, BSUtilities::Rational<I, long(1)> >::Mult 
      pow (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity, 
                                            typename Loki::Int2Type<I>)
          {
            return typename 
              GenerateVariable<Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >,
                BSUtilities::Rational<long(I), long(1)> >::Mult
                              (quantity.pow(Loki::Int2Type<I> ()));
          }


template<template<typename, typename> class Q, typename QT, 
                         typename ST, typename SU, typename DQT, long N, long D>
  inline typename GenerateVariable
    <Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >, BSUtilities::Rational<N, D> >::Mult 
      pow (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity, 
                                   const BSUtilities::Rational<N, D> &)
      { return typename 
          GenerateVariable <Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >,
                                     BSUtilities::Rational<N, D> >::Mult
            (quantity.pow(BSUtilities::Rational<N, D> ()));
          }


template<template<typename, typename> class Q, typename QT, 
                             typename ST, typename SU, typename DQT, typename T>
  inline Dynamic<ST> 
    pow (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity, const T &exp) 
          {return Dynamic<ST> (quantity.pow(exp));}


template<template<typename, typename> class Q, typename QT, 
                                          typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    abs (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &variable)
    {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                              (std::abs (variable.value ()));}


template<template<typename, typename> class Q, typename QT, 
                                         typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    ceil (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &variable)
    {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                               (std::ceil (variable.value ()));}


template<template<typename, typename> class Q, typename QT, 
                                          typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    floor (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &variable)
    {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                                (std::floor (variable.value ()));}


template<template<typename, typename> class Q, typename QT, 
                                           typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    frexp (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &variable, int *exponent)
    {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                        (std::frexp (variable.value (), exponent));}


template<template<typename, typename> class Q, typename QT, 
                                          typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    ldexp (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &variable, int exponent)
    {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                    (std::ldexp (variable.value (), exponent));}


template<template<typename, typename> class Q1, 
  template<typename, typename> class Q2, typename QT, 
                                        typename ST, typename SU, typename DQT>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    fmod (const Q1<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity1,
                      const Q2<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity2)
    {return 
      Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
            (std::fmod (quantity1.value (), quantity2.value ()));
    }


template<template<typename, typename> class Q1, 
  template<typename, typename> class Q2, typename QT, 
            typename ST, typename SU, typename DQT1, class DQT2> 
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT1> >
    fmod (const Q1<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT1> > &quantity1,
                      const Q2<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT2> > &quantity2)
  {return 
    Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT1> >
      (unit::Reverse<SU>::VAL 
        (std::fmod (quantity1.standard_value (), quantity2.standard_value ())));
  }


template <template<typename, typename> class Q1, typename QT1, 
        typename ST, typename SU1, typename DQT1, 
  template<typename, typename> class Q2, typename QT2, typename SU2, typename DQT2> 
  inline Variable<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> >
    fmod (const Q1<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> > &quantity1,
                        const Q2<Quantity<QT2, ST>, DerivedQuantity<QT2, SU2, DQT2> > &quantity2)
  {return Variable<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> >
    (unit::Reverse<SU1>::VAL 
      (std::fmod (quantity1.standard_value (), unit::Standard<typename CheckSecondDimension<
        Q1<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> >, 
          Q2<Quantity<QT2, ST>, DerivedQuantity<QT2, SU2, DQT2> >
                     >::RET::SU>::VAL (quantity2.value ()))));
  }


template<template<typename, typename> class Q, typename QT, 
                                       typename ST, typename SU, typename DQT> 
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
    modf (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity,
                       Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > *integral)
  {ST i_ptr; 
    Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >
                   new_variable (std::modf (quantity.value (), &i_ptr));
    Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > int_quantity (i_ptr);
                          *integral = int_quantity; return new_variable;
        }


template<template<typename, typename> class Q, typename QT, 
          typename ST, typename SU1, typename DQT1, typename SU2, typename DQT2>
  inline Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU1, DQT1> >
    modf (const Q<Quantity<QT, ST>, DerivedQuantity<QT, SU1, DQT1> > &quantity,
                       Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU2, DQT2> > *integral)
  {ST i_ptr; 
    Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU1, DQT1> >
                   new_variable (std::modf (quantity.value (), &i_ptr));
    *integral = Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU2, DQT2> >
                   (Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU1, DQT1> >(i_ptr)); 
    return new_variable;
  }


template<template<typename, typename> class Q, typename QT1, 
               typename SU1, typename DQT1, typename QT2, typename SU2, typename DQT2, typename ST>
  inline Variable<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> >
  modf (const Q<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> > &quantity,
                            Variable<Quantity<QT2, ST>, DerivedQuantity<QT2, SU2, DQT2> > *integral)
  {ST i_ptr; 
    typename CheckSecondDimension<Variable<Quantity<QT2, ST>, DerivedQuantity<QT2, SU2, DQT2> >,
      Variable<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> > >::RET
        new_variable (unit::Reverse<SU1>::VAL 
                      (std::modf (quantity.standard_value (), &i_ptr)));
    *integral = Variable<Quantity<QT2, ST>, DerivedQuantity<QT2, SU2, DQT2> >
            (Variable<Quantity<QT1, ST>, DerivedQuantity<QT1, SU1, DQT1> >(i_ptr)); 
  return new_variable;
  }

//  mathematical functions producing a dimensionless result
//  exp,log, and trigonometric function


      struct Dummy;


#define QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(function, helper) \
template<typename QT, typename ST> struct helper {static ST exec (const Quantity<QT, ST> &quantity) \
{return ST(std::function (quantity.value ()));}}; \
template<template<typename, typename> class M, typename QT, typename ST, typename SU, typename DQT> \
inline typename GenerateVariable<M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >, \
BSUtilities::Rational<0> >::Mult \
function (const M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity) \
{return typename GenerateVariable<M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> >, \
BSUtilities::Rational<0> >::Mult (BSUtilities::IF<CheckDimensionality<Quantity<QT, ST> >::RET, \
typename helper<QT, ST>::helper, Dummy>::RET::exec (quantity));}

QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(exp, expHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(log, logHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(log10, log10Helper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(sin, sinHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(cos, cosHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(tan, tanHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(sinh, sinhHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(cosh, coshHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(tanh, tanhHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(asin, asinHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(acos, acosHelper)
QUANTITY_VARIABLE_DIMENSIONLESS_MATHFCT(atan, atanHelper)


template<template<typename, typename> class M1, typename QT1, typename ST1, typename SU1, typename DQT1,
     template<typename, typename> class M2, typename QT2, typename ST2, typename SU2, typename DQT2>
  inline typename GenerateVariable<M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> >, 
    M2<Quantity<QT2, ST2>, DerivedQuantity<QT1, SU2, DQT2> > >::Sub 
    atan2 (const M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> > &quantity,
                           const M2<Quantity<QT2, ST2>, DerivedQuantity<QT1, SU2, DQT2> > &quantity2)
      {return typename GenerateVariable<typename BSUtilities::IF<SameDimensioned<Quantity<QT1, ST1>,
         Quantity<QT2, ST2> >::EQ, M1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SU1, DQT1> >, 
           DimensionError<true> >::RET, M2<Quantity<QT2, ST2>, DerivedQuantity<QT1, SU2, DQT2> > >::Sub
          (std::atan2 (quantity.standard_value (), quantity2.standard_value ()));}

//  end mathematical functions producing a dimensionless result

} // end namespace quantity

#endif /* _Variable_h */

---