DedimensionalizedVariable.h

Go to the documentation of this file.

/* Copyright (C) 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 _DedimensionalizedVariable_h
#define _DedimensionalizedVariable_h

#include "Quantity/Unit.h"
#include "Quantity/Variable.h"
#include "Quantity/Dedimensionalization.h"

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

namespace quantity {

//
//  Helper classes and structs 
//

typedef BSUtilities::Rational<0> DedimensionalizedLE;
typedef BSUtilities::Rational<0> DedimensionalizedM;
typedef BSUtilities::Rational<0> DedimensionalizedTI;
typedef BSUtilities::Rational<0> DedimensionalizedE;
typedef BSUtilities::Rational<0> DedimensionalizedTE;
typedef BSUtilities::Rational<0> DedimensionalizedA;
typedef BSUtilities::Rational<0> DedimensionalizedLU;


typedef dimension::Dimension<DedimensionalizedLE, DedimensionalizedM, 
  DedimensionalizedTI, DedimensionalizedE, DedimensionalizedTE, 
    DedimensionalizedA, DedimensionalizedLU> 
                                     DedimensionalizedVariableDimension;
}

namespace unit {
class DedimensionalizedUnit;

class DedimensionalizedUnityUnit;

typedef NonPrefixable<DedimensionalizedUnit, DedimensionalizedUnityUnit>
                                                 DedimensionalizedUnity;

typedef LOKI_TYPELIST_1(DedimensionalizedUnity) DedimensionalizedUnits;

}

namespace quantity {

//
//  the DedimensionalizedVariable classes
//


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


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 DedimensionalizedVariable<
    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<DedimensionalizedVariableDimension, 
        unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                                       unit::DedimensionalizedUnity, ST>
    {
      public:

        typedef DedimensionalizedVariableDimension 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<DedimensionalizedVariableDimension, 
          unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                                   unit::DedimensionalizedUnity, ST> ABQ;

        typedef 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> V;


        typedef 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> PQ;


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


        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:

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


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


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


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


        DedimensionalizedVariable 
          (const V &value, const V &dedimensionalizationValue, 
                                            const DD &dedimensionalizer)
            : ABQ (), _dedimensionalizer (dedimensionalizer) ,
              _value (value.value ()/dedimensionalizationValue.value ())
                                                                      {}


        template<class SU1>
          DedimensionalizedVariable 
            (const V &value, const 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> 
                &dedimensionalizationValue, const DD &dedimensionalizer)
            : ABQ (), _dedimensionalizer (dedimensionalizer), 
                          _value (value.value ()/ Reverse<SU, ST>::VAL 
                        (dedimensionalizationValue.standard_value())) {}


        DedimensionalizedVariable 
          (const DedimensionalizedVariable &variable)
            : ABQ (), _dedimensionalizer (variable._dedimensionalizer), 
                                              _value (variable.value ())
              {ABQ::namestring = variable.name ();
               ABQ::symbolstring = variable.symbol ();
              }
 
//    dedimensionalizationValue; then copy the name and symbol string 
//*/
//        template<template<class, class> class Q1>
//          DedimensionalizedVariable (const Q1<PQ, unit::DedimensionalizedUnity> 
//                                                              &quantity)
//            : ABQ (), _value (quantity.value ())
//              {ABQ::namestring = quantity.name ();
//               ABQ::symbolstring = quantity.symbol ();
//              }
// 
//    unit list typical for a generated quantity using a GenericUnit; 
//    this special case is the only exception when a quantity of 
//    different base unit type can be converted into the target 
//    dedimensionalized variable,
//    provided the dimensions of the two objects are equal. This is
//    tested with CheckSecondDimension.
//    It is assumed that the storage type of the two objects is identical.
//*/
//        template<template<class, class> class Q1, 
//                            class BT1, class DIM1, class DU1, class SU1>
//          DedimensionalizedVariable (const Q1<Quantity<DIM1, BT1,
//            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
//              Loki::NullType>, DU1, ST>, SU1> &quantity, 
//                                                   V dedimensionalizationValue)
//            : ABQ (), _value (Reverse<Unit, ST>::VAL
//              (Standardize<typename
//                 CheckSecondDimension<DedimensionalizedVariable,
//                   Q1<Quantity<DIM1, BT1,
//                     Loki::Typelist<unit::NonPrefixable<BT1, 
//                       unit::GenericUnit>, Loki::NullType>, 
//                         DU1, ST>, SU1> >::RET::Unit, ST>::VAL
//                           (quantity.value ())/
//                                  dedimensionalizationValue.standard_value ()))
//              {namestring = quantity.name ();
//               symbolstring = quantity.symbol ();
//              }
//
//    dimensional information in Dynamic; the Dynamic must have the 
//    same dimension as dedimensionalizationValue; 
//*/
//        DedimensionalizedVariable 
//          (const Dynamic<ST> &dynamic, V &dedimensionalizationValue)
//          : ABQ ()
//          {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 = dynamic.value ()/
//                                   dedimensionalizationValue.standard_value ();
//
//            else
//               {throw DimensionMismatch ();}
//
//          }
//
//    can be done by direct comparison of pointers; no need to convert
//    values, since unit must be the same; raw value of new_variable
//    is used, since no conversion into default unit is desired;
//    only the variable value and the dedimensionalization value are assigned, 
//    name and symbol are not touched.
//*/
//        DedimensionalizedVariable & operator= 
//                                (const DedimensionalizedVariable &new_variable)
//          {if (this != &new_variable)
//            {_value = new_variable.value ();
//            }
//
//           return *this;
//          }
//
//?????????????????? correct ???????????????????????????
//    if trying to instantiate, PQ and PQ1 should be different, since
//    the case of PQ and PQ1 being the same type is handled by the
//    assignment operator given above. Thus,
//    SameType<>::sameType is always false and the IF construct tries to
//    instantiate DimensionError<true> which is never defined.
//    Consequently, this should never be instantiated correctly.
//    This should also avoid assignment from GenericQuantity and Dynamic,
//    which is impossible since no dedimensionalizationValue can be supplied.
//*/
//        template<template<class, class> class Q1, class PQ1, class SU1>
//          DedimensionalizedVariable & operator= (const Q1<PQ1, SU1> &quantity)
//          {
//            static const bool RET = BSUtilities::IF<BSUtilities::
//              SameType<DedimensionalizedVariable, Q1<PQ1, SU1> >::sameType, 
//                AssignmentError<false>, AssignmentError<true> 
//                                                            >::RET::RET;
//            return *this;
//          }


        ST value (void) const {return _value;}


        ST standard_value (void) const {return _value;}


        ST value (const unit::DedimensionalizedUnity &) const 
                                                {return _value;}

//    Variable defining the DedimensionalizedVariable is returned with the 
//    resulting value; since DedimensionalizedUnity
//    is the only unit and the standardization factor is unity, no
//    recalculation is necessary.
//*/
//        V deDimensionalize (V dedimensionalizationValue) const 
//                       {return V(_value * dedimensionalizationValue);}
//
//    Consequently, when supplying an incorrect string for the symbol,
//    this can not be detected at compile time, but only at run time.
//    Only empty string is possible for symbol. If symbol is not found by 
//    findBySymbol, a UnitMismatch exception is thrown.
//*/
//        ST value (const std::string &symbol)
//          {
//           ::unit::Unit<BT> *unitp = PQ::findBySymbol (symbol);
//           delete (unitp);
//
//           return _value;
//          }
//
//    present for analogy to Variable, just makes a copy.
//*/
//        DedimensionalizedVariable operator () 
//                                   (const unit::DedimensionalizedUnity &) const
//          {return DedimensionalizedVariable (_value);}
//

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


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


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


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


        DedimensionalizedVariable & operator+= 
                             (const DedimensionalizedVariable &variable)
          {_value += variable.value ();
           return *this;
          }


        template <template<class, class> class Q1, class BT1,
                                       class DIM1, class DU1, class SU1>
          DedimensionalizedVariable & operator+= 
            (const Q1<Quantity<DIM1, BT1, 
            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
                              Loki::NullType>, DU1, ST>, SU1> &quantity)
            {_value += 
                Standardize<typename CheckSecondDimension<
                  DedimensionalizedVariable, 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>
          DedimensionalizedVariable & 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;
          }


        DedimensionalizedVariable & operator-= 
                         (const DedimensionalizedVariable &new_variable)
          {
           _value -= new_variable.value (); 
           return *this;
          }

//    for a right hand side operand which is a generated quantity having a
//    generic unit and the same dimension as the left hand side operand;
//    value of both operands recalculated into standard unit, reverse
//    standardization of the result before stored in _value.
//*/
//        template <template<class, class> class Q1, class BT1,
//                                       class DIM1, class DU1, class SU1>
//          DedimensionalizedVariable & operator-= (const Q1<Quantity<DIM1, BT1, 
//            Loki::Typelist<unit::NonPrefixable<BT1, unit::GenericUnit>,
//                              Loki::NullType>, DU1, ST>, SU1> &quantity)
//            {_value -= 
//                Standardize<typename CheckSecondDimension<
//                  DedimensionalizedVariable, Q1<Quantity<DIM1, BT1, 
//                    Loki::Typelist<unit::NonPrefixable<BT1, 
//                      unit::GenericUnit>, Loki::NullType>, DU1, ST>,
//                        SU1> >::RET::Unit, ST>::VAL 
//                                                   (quantity.value ());
//              return *this;
//            }
//
//    where the second is NOT a generated quantity; should never compile,
//    but rather yield a DimensionError<true> compiler error message
//*/
//        template<template<class, class> class Q1, class PQ1, class SU1>
//          DedimensionalizedVariable & 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;
//          }
//
//    assigned to a ST in general
//*/
//        DedimensionalizedVariable & operator*= (const ST factor)
//           {_value *= factor;
//             return *this;
//           }
//
//    operation with a left hand side ST can not be assigned to a ST 
//    in general
//*/
//        DedimensionalizedVariable & operator/= (const ST divisor)
//           {_value /= divisor;
//             return *this;
//           }
//  

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


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


        template <template<class, class> class Q1, class DIM1,
                             class BT1, class UL1, class DU1, class SU1>
          DedimensionalizedVariable operator+ 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> &quantity)
                                                                   const
          {DedimensionalizedVariable new_object (*this);
            return new_object += quantity;
          }

//    side of the operator; this is converted into an object of the left 
//    hand side type; this is only successful at run time, if the Dynamic
//    object is commensurate; failure is indicated by a DimensionMismatch
//    exception; finally addition is forwarded to the `generic' addition 
//    operator above.
//*/
//        DedimensionalizedVariable operator+ (const Dynamic<ST> &quantity) const
//          {DedimensionalizedVariable new_variable (quantity);
//           return *this + new_variable;
//          }
//
//

        template <template<class, class> class Q1, class DIM1,
                             class BT1, class UL1, class DU1, class SU1>
          DedimensionalizedVariable operator- 
            (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> &quantity)
                                                                   const
          {DedimensionalizedVariable new_object (*this);
            return new_object -= quantity;
          }

//    side of the operator; this is converted into an object of the left 
//    hand side type; this is only successful at run time, if the Dynamic
//    object is commensurate; failure is indicated by a DimensionMismatch
//    exception; finally addition is forwarded to the `generic' addition 
//    operator above.
//*/
//        DedimensionalizedVariable operator- (const Dynamic<ST> &quantity) const
//          {DedimensionalizedVariable new_variable (quantity);
//           return *this - new_variable;
//          }
//
//*/
//        DedimensionalizedVariable operator* (const ST factor) const
//          {DedimensionalizedVariable new_object (*this);
//            return new_object *= factor;
//          }
//
//*/
//        DedimensionalizedVariable operator/ (const ST divisor) const
//          {DedimensionalizedVariable new_object (*this);
//            return new_object /= divisor;
//          }
//
//    conversions, this may also work for factors with a type different
//    from ST, as long as it can be matched;
//    out of class declaration without friend does not work  with
//    factor type different from storage type, since in that case
//    first the template argument ST is deducted from the first 
//    function argument, and 'this deduction does not consider ...
//    conversions' (Vandevoorde/Josuttis, p. 489);
//    second argument can be quantity object of any mode.
//*/
//        template <template<class, class> class Q1>
//          friend DedimensionalizedVariable operator* 
//            (const ST factor, 
//                          const Q1<PQ, unit::DedimensionalizedUnity> &variable)
//                       {return DedimensionalizedVariable (variable) *= factor;}


        bool operator== 
                   (const DedimensionalizedVariable &rhs_variable) const
                               {return _value == rhs_variable.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<DedimensionalizedVariable, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }


        bool operator!= 
                   (const DedimensionalizedVariable &rhs_variable) const
                       {return _value != rhs_variable.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<DedimensionalizedVariable, 
                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
            }

//    use value to retrieve the variabler value of the right hand side
//    Variable and directly compare to _value.
//*/
//        bool operator> (const DedimensionalizedVariable &rhs_variable) const
//                       {return _value > rhs_variable.value ();}
//
//    possibly different storage units SU and SU1;
//    compares the values in the standard unit; we can be sure
//    that values can be recalculated between SU and SU1.
//*/
//        template <template<class, class> class Q1, class SU1>
//          bool operator> (const Q1<PQ, SU1> &rhs_variable) const
//            {return standard_value () > rhs_variable.standard_value ();
//            }
//
//    compares the values in the standard unit; to check dimension,
//    the standardization call is generated through a compile time check; 
//    this should handle generated transient quantities as rhs argument.
//*/
//        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<DedimensionalizedVariable, 
//                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
//                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
//            }
//
//    use value to retrieve the variabler value of the right hand side
//    Variable and directly compare to _value.
//*/
//        bool operator< (const DedimensionalizedVariable &rhs_variable) const
//                       {return _value < rhs_variable.value ();}
//
//    possibly different storage units SU and SU1;
//    compares the values in the standard unit; we can be sure
//    that values can be recalculated between SU and SU1.
//*/
//        template <template<class, class> class Q1, class SU1>
//          bool operator< (const Q1<PQ, SU1> &rhs_variable) const
//            {return standard_value () < rhs_variable.standard_value ();
//            }
//
//    compares the values in the standard unit; to check dimension,
//    the standardization call is generated through a compile time check; 
//    this should handle generated transient quantities as rhs argument.
//*/
//        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<DedimensionalizedVariable, 
//                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
//                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
//            }
//
//    use value to retrieve the variabler value of the right hand side
//    Variable and directly compare to _value.
//*/
//        bool operator>= (const DedimensionalizedVariable &rhs_variable) const
//                      {return _value >= rhs_variable.value ();}
//
//    possibly different storage units SU and SU1;
//    compares the values in the standard unit; we can be sure
//    that values can be recalculated between SU and SU1.
//*/
//        template <template<class, class> class Q1, class SU1>
//          bool operator>= (const Q1<PQ, SU1> &rhs_variable) const
//            {return standard_value () >= rhs_variable.standard_value ();
//            }
//
//    compares the values in the standard unit; to check dimension,
//    the standardization call is generated through a compile time check; 
//    this should handle generated transient quantities as rhs argument.
//*/
//        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<DedimensionalizedVariable, 
//                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
//                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
//            }
//
//    use value to retrieve the variabler value of the right hand side
//    Variable and directly compare to _value.
//*/
//        bool operator<= (const DedimensionalizedVariable &rhs_variable) const
//                       {return _value <= rhs_variable.value ();}
//
//    possibly different storage units SU and SU1;
//    compares the values in the standard unit; we can be sure
//    that values can be recalculated between SU and SU1.
//*/
//        template <template<class, class> class Q1, class SU1>
//          bool operator<= (const Q1<PQ, SU1> &rhs_variable) const
//            {return standard_value () <= rhs_variable.standard_value ();
//            }
//
//    compares the values in the standard unit; to check dimension,
//    the standardization call is generated through a compile time check; 
//    this should handle generated transient quantities as rhs argument.
//*/
//        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<DedimensionalizedVariable, 
//                 Q1<Quantity<DIM1, BT1, UL1, DU1, ST>, SU1> 
//                         >::RET::Unit, ST>::VAL (rhs_variable.value ());
//            }
//
//    adding the dimensions of the two quantities;
//    only GenerateVariable with two quantities as arguments does
//    have an Add typedef, thus, Q does not need to be specified.
//*/
//        template<class Q>
//          Q operator* (const Q &factor) const
//              {return Q (standard_value () * factor.standard_value ());}
//
//    subtracting the dimensions of the two quantities;
//    only GenerateVariable with two quantities as arguments does
//    have an Sub typedef, thus, Q does not need to be specified.
//*/
//        template<class Q>
//          typename GenerateVariable<Q, Loki::NullType>::Inv 
//                                       operator/ (const Q &factor) const
//            {
//              return typename 
//                GenerateVariable<Q, Loki::NullType>::Inv 
//                         (standard_value () / factor.standard_value ());
//            }
//
//    negating the dimension of the variable;
//*/
//        friend typename 
//          GenerateVariable<DedimensionalizedVariable, Loki::NullType>::Inv 
//            operator/ (const ST numerator, 
//                                       const DedimensionalizedVariable &factor)
//          {
//            return typename 
//              GenerateVariable<DedimensionalizedVariable, Loki::NullType>::Inv 
//                                 (numerator / factor.standard_value ());
//          }
//
//    first argument multiplied by Rational<N, D>;
//    used as object.pow (r);
//    forwards action to pow function with quantity and rational
//    exponent (in namespace quantities).
//*/
//        template<long N, long D>
//          typename GenerateVariable<DedimensionalizedVariable, 
//                                     BSUtilities::Rational<N, D> >::Mult
//                               pow (const BSUtilities::Rational<N, D> &)
//          {return 
//             ::quantity::pow (*this, BSUtilities::Rational<N, D> ());}
//
//    first argument multiplied by I;
//    used as object.pow (r);
//    forwards action to pow function with quantity and static integer
//    exponent (in namespace quantities).
//*/
//        template<int I>
//          typename GenerateVariable<DedimensionalizedVariable, 
//              BSUtilities::Rational<I, long(1)> >::Mult 
//                                        pow (typename Loki::Int2Type<I>)
//          {return ::quantity::pow (*this, Loki::Int2Type<I> ());}
//
//    first argument multiplied by exp;
//    alternative formulation;
//    forwards action to pow function with quantity and dynamic 
//    exponent (friend functions in Dynamic for specific T's).
//*/
//    template<class T>
//      Dynamic<ST> pow (const T &exp) const
//                                {return ::quantity::pow (*this, exp);}
//
//*/
//        friend typename 
//          GenerateVariable<DedimensionalizedVariable, 
//            BSUtilities::Rational<1, 2> >::Mult sqrt 
//                                    (const DedimensionalizedVariable &variable)
//          {
//            return typename 
//              GenerateVariable<DedimensionalizedVariable, 
//                BSUtilities::Rational<1, 2> >::Mult 
//                                (std::sqrt(variable.standard_value ()));
//          }
//
//*/
//        typename GenerateVariable<DedimensionalizedVariable, 
//                   BSUtilities::Rational<1, 2> >::Mult sqrt (void) const
//          {
//            return typename 
//              GenerateVariable<DedimensionalizedVariable, 
//                BSUtilities::Rational<1, 2> >::Mult 
//                                         (std::sqrt(standard_value ()));
//          }


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


      void operator>> (std::string &str) const
        {str = BSUtilities::Conversion<DedimensionalizedVariable>::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, DedimensionalizedVariable &variable) 
//                                            {variable.read_value (str);}
//
//      void operator<< (const std::string &str) {read_value (str);}
//
//      void operator= (const std::string &str) {this->read_value (str);}
//
//    are subsequently interpreted with read_value; the reference to
//    the istream object is returned to allow chaining.
//*/
//      std::istream & operator<< (std::istream &is) 
//        {std::string string; getline (is, string); 
//                                  this->read_value (string); return is;}
//
//    object; uses read from istream to the right of operator<<.
//*/
//      friend std::istream & operator>> 
//        (std::istream &is, DedimensionalizedVariable &variable) 
//                                                {return variable << is;}
//


    void save (BSUtilities::xmlw::XmlStream &os) const
    {
      os << BSUtilities::xmlw::tag (Quantities::TAG)
         << BSUtilities::xmlw::attr (Quantities::MODETAG) << MODE
// to be added ...
      << BSUtilities::xmlw::endtag (Quantities::TAG);
    }


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

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


//    PQ (???) * create (void) {return new DedimensionalizedVariable;}
// 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 DedimensionalizedVariable<
    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 = 
                                            "dedimensionalizedVariable";

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

//    important note: if a name is to be read, a corresponding string
//    token has to be present, similar for symbol!
// */
//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 NFL>
//  void DedimensionalizedVariable<
//    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<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>, NFL> >::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;
// 
//   storage unit
//*/
//      if (start == std::string::npos)
//      {
//        std::string assume_unit;
//
//   (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 ();}
//
//        }
//      }
//
//   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 ();}
//      }
//      
//
//
//    }

template<class ST>
  struct Name<Quantity<DedimensionalizedVariableDimension, 
    unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                                     unit::DedimensionalizedUnity, ST> >
  {
    static const std::string String;
  };

template<class ST>
  const std::string
    Name<Quantity<DedimensionalizedVariableDimension, 
      unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                       unit::DedimensionalizedUnity, ST> >::String = "";

template<class ST>
  struct Symbol<Quantity<DedimensionalizedVariableDimension, 
    unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                                     unit::DedimensionalizedUnity, ST> >
  {
    static const std::string String;
  };

template<class ST>
  const std::string
    Symbol<Quantity<DedimensionalizedVariableDimension, 
      unit::DedimensionalizedUnit, unit::DedimensionalizedUnits, 
                       unit::DedimensionalizedUnity, ST> >::String = "";
}

#endif /* _DedimensionalizedVariable_h */

---