Variable.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2004, 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/Generic.h"

namespace Quantities {

//
//  Helper classes and structs 
//


template<class Q1, class Q2> struct GenerateVariable;

//
//  the Variable classes
//


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

template<class GT, class Head, class Tail, class DU, class SU, class ST>
  class Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, SU>
              : public Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>
    {
      private:

        typedef typename 
               Units::CheckUnit<Units::Unit<GT, ST>, SU>::Check Checked;
      public:

        typedef Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> PQ;

        typedef SU Unit;

      protected:

        ST variable_value;

      public:

        Variable (void) : variable_value (ST(0.0)) {};


        Variable (const ST new_value) : variable_value (new_value) {}


        Variable (const ST new_value, const SU &) 
                                        : variable_value (new_value) {}
            


        template<class NU>
          Variable (const ST new_value, const NU &) 
            : PQ (), variable_value (SU::Reverse 
              (CheckAgainstAllUnits<NU, Loki::Typelist<Head, Tail> 
                                       >::RET::Standard (new_value))) {}


        Variable (const ST new_value, const std::string &unitsymbol) 
            : PQ ()
        { 
          ::Units::Unit<GT, ST> *unitp = PQ::findBySymbol (unitsymbol);
          variable_value = SU::Reverse (unitp->standard (new_value));

          delete (unitp);
        }


        Variable (const ST new_value, const char * unitsymbol) 
            : PQ ()
        { 
          ::Units::Unit<GT, ST> *unitp 
                          = PQ::findBySymbol (std::string (unitsymbol));
          variable_value = SU::Reverse (unitp->standard (new_value));

          delete (unitp);
        }


        Variable (const Variable &new_variable) 
          : PQ (), variable_value (new_variable.variable_value)
            { 
              namestring = new_variable.namestring;
              symbolstring = new_variable.symbolstring;
            }
 

        template<template<class, class> class Q1, class SU1>
            Variable (const Q1<PQ, SU1> &source_quantity)
            : PQ (), variable_value (SU::Reverse 
              (SU1::Standard (source_quantity.value ())))
              { 
                namestring = source_quantity.name ();
                symbolstring = source_quantity.symbol ();
              }


        template<template<class, class> class Q1, class GT1, 
                                                   class DU1, class SU1>
          Variable (const Q1<Quantity<GT1, 
            Loki::Typelist<Units::NonPrefixable<GT1, 
              Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, SU1> 
                                                       &source_quantity)
            : PQ (), variable_value (Unit::Reverse 
              (Units::NonPrefixable<typename
                 CheckSecondDimension<Variable<PQ, SU>, 
                   Q1<Quantity<GT1, Loki::Typelist<Units::NonPrefixable
                      <GT1, Units::GenericUnit, ST>, 
                        Loki::NullType>, DU1, ST>, SU1> >::RET::Type, 
                          Units::GenericUnit, ST>::Standard 
                                        (source_quantity.value ())))
              { 
                namestring = source_quantity.name ();
                symbolstring = source_quantity.symbol ();
              }


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


        ST standard_value (void) const 
                                 {return SU::Standard (variable_value);}


        ST value (void) const {return variable_value;}


        template<class NU>
          ST value (const Units::NonPrefixable<GT, NU, ST> &) const 
            {return 
              CheckAgainstAllUnits<Units::NonPrefixable<GT, NU, ST>, 
                Loki::Typelist<Head, Tail> >::RET::Reverse 
                                       (SU::Standard (variable_value));}


        template<class NU, class P>
          ST value 
            (const Units::Prefixed<Units::Prefixable<GT, NU, ST>, P> &)
                                                                   const
            {return 
               CheckAgainstAllUnits
                     <Units::Prefixed<Units::Prefixable<GT, NU, ST>, P>,
                 Loki::Typelist<Head, Tail> >::RET::Reverse 
                                       (SU::Standard (variable_value));}


        template<class CUL, class EL>
          ST value 
            (const Units::Composed<Units::Compound<GT, CUL, ST>, EL> &)
                                                                   const
            {return 
              CheckAgainstAllUnits
                     <Units::Composed<Units::Compound<GT, CUL, ST>, EL>,
                Loki::Typelist<Head, Tail> >::RET::Reverse 
                                       (SU::Standard (variable_value));}


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

            value = unitp->reverse (SU::Standard (variable_value));

            delete (unitp);

            return value;
          }


        template<class NU>
          Variable<PQ, NU> operator () (const NU &) const 
            {return Variable<PQ, NU> (variable_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 ();}


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

               if (this_pointer != new_pointer)
               {
                 variable_value = SU::Reverse 
                         (SU1::Standard (source_quantity.value ()));
               }

               return *this;
             }


        template<template<class, class> class Q1, class GT1, 
                                                   class DU1, class SU1>
          Variable & operator= (const Q1<Quantity<GT1, 
            Loki::Typelist<Units::NonPrefixable<GT1, 
                Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, SU1>
                                                       &source_quantity)
             {
               void *this_pointer = this;
               const void *new_pointer = &source_quantity;

               if (this_pointer != new_pointer)
               {
                 variable_value = SU::Reverse 
                   (Units::NonPrefixable<typename
                     CheckSecondDimension<Variable<PQ, SU>, 
                       Q1<Quantity<GT1, 
                         Loki::Typelist<Units::NonPrefixable<GT1,
                           Units::GenericUnit, ST>, Loki::NullType>, 
                             DU1, ST>, SU1> >::RET::Type, 
                               Units::GenericUnit, ST>::Standard
                                        (source_quantity.value ()));
               }

               return *this;
             }


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

            return *this;
          }


        template <template<class, class> class Q1, class SU1>
          Variable & operator+= (const Q1<PQ, SU1> &new_variable)
             {ST val = Unit::Standard (variable_value);
              variable_value = SU::Reverse (val += 
                             SU1::Standard (new_variable.value ()));
               return *this;
             }


        template <template<class, class> class Q1, class GT1, 
                                                   class DU1, class SU1>
          Variable & operator+= (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &new_variable)
             {ST val = Unit::Standard (variable_value);
              variable_value = SU::Reverse (val += 
                Units::NonPrefixable<typename
                  CheckSecondDimension<Variable<PQ, SU>, 
                    Q1<Quantity<GT1, 
                      Loki::Typelist<Units::NonPrefixable<GT1, 
                        Units::GenericUnit, ST>, Loki::NullType>, 
                          DU1, ST>, SU1> >::RET::Type, 
                            Units::GenericUnit, ST>::Standard 
                                           (new_variable.value ()));
               return *this;
             }


        template <template<class, class> class Q1, 
              class GT1, class Head1, class Tail1, class DU1, class SU1>
          Variable & operator+= 
            (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, 
                                           DU1, ST>, SU1> &new_variable)
             {ST val = BSUtilities::IF<BSUtilities::SameType<SU,
               Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                >::sameType, SU, Units::UnitError<false> 
                  >::RET::Standard (variable_value);
              variable_value = SU::Reverse (val += 
                CheckSecondDimension<Variable<PQ, SU>, 
                  Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, 
                    ST>, SU1> >
                     ::RET::Unit::Standard (new_variable.value ()));
               return *this;
             }


        template <template<class, class> class Q1, class SU1>
          Variable & operator-= (const Q1<PQ, SU1> &new_variable)
             {ST val = SU::Standard (variable_value);
               variable_value = SU::Reverse (val -=
                             SU1::Standard (new_variable.value ()));
               return *this;
             }


        template <template<class, class> class Q1, class GT1,
                                                   class DU1, class SU1>
          Variable & operator-= (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &new_variable)
             {ST val = SU::Standard (variable_value);
              variable_value = SU::Reverse (val -=
                Units::NonPrefixable<typename
                  CheckSecondDimension<Variable<PQ, SU>,
                    Q1<Quantity<GT1, 
                      Loki::Typelist<Units::NonPrefixable<GT1,
                        Units::GenericUnit, ST>, Loki::NullType>, 
                          DU1, ST>, SU1> >::RET::Type, 
                                       Units::GenericUnit, ST>::Standard
                                           (new_variable.value ()));
               return *this;
             }


        template <class Q>
          Variable & operator-= (const Q &new_variable)
             {ST val = BSUtilities::IF<BSUtilities::SameType<Unit,
               Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                 >::sameType, Unit, Units::UnitError<false> 
                                      >::RET::Standard (variable_value);
              variable_value = Unit::Reverse (val -=
                CheckSecondDimension<Variable<PQ, SU>, Q>
                     ::RET::Unit::Standard (new_variable.value ()));
               return *this;
             }

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

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

        Variable operator+ (void) const
           {Variable<PQ, SU> new_variable (*this);
             return new_variable;
           }


        Variable operator- (void) const
           {Variable<PQ, SU> new_variable (*this);
             return new_variable *= -1.0;
           }


        template <class Q>
          Variable operator+ (const Q &new_variable) const
            {Variable<PQ, SU> new_object (*this);
              return new_object += new_variable;
            }


        template <class Q>
          Variable operator- (const Q &new_variable) const
            {Variable<PQ, SU> new_object (*this);
              return new_object -= new_variable;
            }


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


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


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


        friend Variable abs (const Variable &variable)
        {Variable<PQ, SU> new_variable (variable);
           return new_variable.variable_value 
                                         = std::abs (variable.value ());
        }


        friend Variable ceil (const Variable &variable)
        {Variable<PQ, SU> new_variable (variable);
           return new_variable.variable_value 
                                        = std::ceil (variable.value ());
        }


        friend Variable floor (const Variable &variable)
        {Variable<PQ, SU> new_variable (variable);
           return new_variable.variable_value 
                                       = std::floor (variable.value ());
        }


        friend Variable modf 
                          (const Variable &variable, Variable *integral)
        {Variable<PQ, SU> new_variable (variable);
          ST i_ptr; 
            new_variable.variable_value 
                                = std::modf (variable.value (), &i_ptr);
              Variable<PQ, SU> int_quantity (i_ptr); 
                *integral = int_quantity; return new_variable;
        }


        friend Variable frexp (const Variable &variable, int *exponent)
        {Variable<PQ, SU> new_variable (variable);
           return new_variable.variable_value 
                             = std::frexp (variable.value (), exponent);
        }


        friend Variable ldexp (const Variable &variable, int exponent)
        {Variable<PQ, SU> new_variable (variable);
           return new_variable.variable_value 
                             = std::ldexp (variable.value (), exponent);
        }


        template <template<class, class> class Q1, class SU1>
          friend Variable fmod 
                (const Variable &variable, const Q1<PQ, SU1> &quantity)
          {return Variable<PQ, SU>
            (SU::Reverse (std::fmod (variable.standard_value (), 
                                         quantity.standard_value ())));
          }


        template <template<class, class> class Q1, class GT1, 
                                                   class DU1, class SU1>
          friend Variable fmod 
            (const Variable &variable, const Q1<Quantity<GT1,
              Loki::Typelist<Units::NonPrefixable<GT1, 
                Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, SU1>
                                                              &quantity)
            {
             return Variable<PQ,SU>
               (SU::Reverse 
                 (std::fmod (variable.standard_value (),
                   CheckSecondDimension<Variable<PQ, SU>, 
                     Q1<Quantity<GT1, 
                       Loki::Typelist<Units::NonPrefixable<GT1,
                         Units::GenericUnit, ST>, Loki::NullType>, 
                           DU1, ST>, SU1> >::RET::Unit::Standard 
                                                 (quantity.value ()))));
            }


        template <template<class, class> class Q1, class GT1, 
          class DU1, class SU1>
          friend Q1<Quantity<GT1, 
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
                               ST>, Loki::NullType>, DU1, ST>, SU1> fmod
            (const Q1<Quantity<GT1,
              Loki::Typelist<Units::NonPrefixable<GT1, 
                Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, SU1>
                                 &variable1, const Variable &variable2)
            {
             return Q1<Quantity<GT1, 
               Loki::Typelist<Units::NonPrefixable<GT1, 
                 Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, 
                                                                    SU1>
               (SU1::Reverse (std::fmod (variable1.standard_value (),
                 CheckSecondDimension< Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1>, Variable
                         >::RET::Unit::Standard (variable2.value ()))));
            }


        bool operator== (const Variable &rhs_variable) const
                   {return variable_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 GT1, 
                                                   class DU1, class SU1>
          bool operator== (const Q1<Quantity<GT1, 
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () == 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard 
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1, 
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator== 
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) == 
               CheckSecondDimension<Variable<PQ, SU>, 
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard 
                                                (rhs_variable.value ());
            }


        bool operator!= (const Variable &rhs_variable) const
                   {return variable_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 GT1,
                                                   class DU1, class SU1>
          bool operator!= (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () !=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1,
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator!=
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) !=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        bool operator> (const Variable &rhs_variable) const
                   {return variable_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 GT1,
                                                   class DU1, class SU1>
          bool operator> (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () >
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                    Units:: GenericUnit, ST>, Loki::NullType>, 
                      DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1,
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator>
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) >
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        bool operator< (const Variable &rhs_variable) const
                   {return variable_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 GT1,
                                                   class DU1, class SU1>
          bool operator< (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () <
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1,
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator<
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) <
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        bool operator>= (const Variable &rhs_variable) const
                   {return variable_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 GT1,
                                                   class DU1, class SU1>
          bool operator>= (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () >=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1,
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator>=
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) >=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        bool operator<= (const Variable &rhs_variable) const
                   {return variable_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 GT1,
                                                   class DU1, class SU1>
          bool operator<= (const Q1<Quantity<GT1,
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
              ST>, Loki::NullType>, DU1, ST>, SU1> &rhs_variable) const
            {
             return standard_value () <=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (rhs_variable.value ());
            }


        template <template<class, class> class Q1, class GT1,
                         class Head1, class Tail1, class DU1, class SU1>
          bool operator<=
           (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                     DU1, ST>, SU1> &rhs_variable) const
            {
             return 
               BSUtilities::IF<BSUtilities::SameType<SU, 
                 Units::NonPrefixable<GT, Units::GenericUnit, ST> 
                   >::sameType, SU, Units::UnitError<false> 
                     >::RET::Standard (variable_value) <=
               CheckSecondDimension<Variable<PQ, SU>,
                 Q1<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                       DU1, ST>, SU1> >::RET::Unit::Standard
                                                (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>::Neg 
            operator/ (const ST numerator, const Variable &factor)
          {
            return typename 
              GenerateVariable<Variable, Loki::NullType>::Neg 
                                 (numerator / factor.standard_value ());
          }


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

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

// NOTE: make general!!!! use something like a `GenerateRational'
        friend typename 
          GenerateVariable<Variable, BSUtilities::Rational<3, 1> >::Mult
            pow (const Variable &variable, const double &exponent)
          {
            return typename 
              GenerateVariable<Variable, 
                                     BSUtilities::Rational<3, 1> >::Mult
                       (std::pow(variable.standard_value (), exponent));
          }


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

// NOTE: make general!!!! use something like a `GenerateRational'
        typename 
          GenerateVariable<Variable, BSUtilities::Rational<3, 1> >::Mult
                                            pow (const double &exponent)
        {
          return typename 
            GenerateVariable<Variable, BSUtilities::Rational<3, 1> 
                        >::Mult (std::pow(standard_value (), exponent));
        }


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

    };

template<class GT, class Head, class Tail, class DU, class SU, class ST>
  void 
    Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, SU>
                                   ::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 {
            ::Units::Unit<GT, ST> *unitp 
                                       = PQ::findBySymbol (assume_unit);
            intermediate = SU::Reverse (unitp->standard (intermediate));

            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 {
          ::Units::Unit<GT, ST> *unitp 
                  = PQ::findBySymbol (unit.substr (start, end - start));

          intermediate = SU::Reverse (unitp->standard (intermediate));

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

      variable_value = intermediate;

    }


template<template<class, class> class Q1, class GT1, class Head1, 
           class Tail1, class DU1, class SU1,
         template<class, class> class Q2, class GT2, class Head2, 
           class Tail2, class DU2, class SU2, class ST>
  struct GenerateVariable
    <Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST>, SU1>, 
         Q2<Quantity<GT2, Loki::Typelist<Head2, Tail2>, DU2, ST>, SU2> >
  {
     private:
       typedef typename 
         Dimensions::Dimension<GT1>::template 
                           Add<Dimensions::Dimension<GT2> >::Class AddT;
       typedef Units::NonPrefixable<GenericClass<AddT>, 
                                           Units::GenericUnit, ST> AddU;
       typedef Loki::Typelist<AddU, Loki::NullType> AddUnits;
       typedef Quantity<GenericClass<AddT>, AddUnits, AddU, ST> 
                                                                AddNewQ;

       typedef typename 
         Dimensions::Dimension<GT1>::template 
                           Sub<Dimensions::Dimension<GT2> >::Class SubT;
       typedef Units::NonPrefixable<GenericClass<SubT>, 
                                           Units::GenericUnit, ST> SubU;
       typedef Loki::Typelist<SubU, Loki::NullType> SubUnits;
       typedef Quantity<GenericClass<SubT>, SubUnits, SubU, ST> SubNewQ;

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


template<template<class, class> class Q1, class GT1, class Head1, 
           class Tail1, class DU1, class SU1, class ST1> 
  struct GenerateVariable
    <Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>, 
                                                         Loki::NullType>
  {
     private:
       typedef typename Dimensions::Dimension<GT1>::Neg::Class NegT;
       typedef Units::NonPrefixable<GenericClass<NegT>, 
                                          Units::GenericUnit, ST1> NegU;
       typedef Loki::Typelist<NegU, Loki::NullType> NegUnits;
       typedef Quantity<GenericClass<NegT>, NegUnits, NegU, ST1> 
                                                                NegNewQ;

     public:
       typedef Variable<NegNewQ, NegU> Neg;
  };


template<template<class, class> class Q1, class GT1, class Head1, 
           class Tail1, class DU1, class ST1, class SU1, long N, long D>
  struct GenerateVariable
    <Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>, 
                                           BSUtilities::Rational<N, D> >
  {
     private:
       typedef typename 
         Dimensions::Dimension<GT1>::template Mult<N, D>::Class MultT;
       typedef Units::NonPrefixable<GenericClass<MultT>, 
                                         Units::GenericUnit, ST1> MultU;
       typedef Loki::Typelist<MultU, Loki::NullType> MultUnits;
       typedef Quantity<GenericClass<MultT>, MultUnits, MultU, ST1> 
                                                               MultNewQ;

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


/*
        template <template<class, class> class Q1, class GT1, 
          class DU1, class SU1,
                  template<class, class> class Q2, class GT2,
                                         class DU2, class SU2, class ST>
          Variable<Quantity<GT1, 
            Loki::Typelist<Units::NonPrefixable<GT1, Units::GenericUnit,
                               ST>, Loki::NullType>, DU1, ST>, SU1> fmod
            (const Variable<Quantity<GT1,
              Loki::Typelist<Units::NonPrefixable<GT1, 
                Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, SU1>
                                                             &variable1,
                  const Variable<Quantity<GT2, 
                    Loki::Typelist<Units::NonPrefixable<GT2, 
                      Units::GenericUnit, ST>, Loki::NullType>, DU2, 
                                                   ST>, SU2> &variable2)
            {
             return Variable<Quantity<GT1, 
               Loki::Typelist<Units::NonPrefixable<GT1, 
                 Units::GenericUnit, ST>, Loki::NullType>, DU1, ST>, 
                                                                    SU1>
               (SU1::Reverse (std::fmod (variable1.standard_value (),
                 CheckSecondDimension<Variable<Quantity<GT1, 
                   Loki::Typelist<Units::NonPrefixable<GT1,
                     Units::GenericUnit, ST>, Loki::NullType>, 
                                                         DU1, ST>, SU1>,
                       Variable<Quantity<GT2, 
                         Loki::Typelist<Units::NonPrefixable<GT2, 
                           Units::GenericUnit, ST>, Loki::NullType>, 
                             DU2, ST>, SU2> >::RET::Unit::Standard 
                                                (variable2.value ()))));
            }
*/

}

#endif /* _Variable_h */

---