QuantityCluster.h

Go to the documentation of this file.

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

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

#include "HierarchyGenerators.h"

#include "xmlwriter.h"
#include "xmlReader.h"
#include <tinyxml/tinyxml.h>

#include <vector>

namespace quantity {

//
//  the Vector abstract base class
//


template<class Q> class Vector;


template<class DIM, class BT, class UL, class DU, class ST>
                            class Vector<Quantity<DIM, BT, UL, DU, ST> >
  {
    private:
      typedef Quantity<DIM, BT, UL, DU, ST> PQ;

    public:
      static const std::string TAG;

      static const std::string MTAG;
      static const std::string QTAG;
      static const std::string UTAG;
      static const std::string DTAG;
      static const std::string VTAG;
  };

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >::TAG
                                                     = "quantityVector";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >
                                                        ::MTAG = "mode";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >
                                                    ::QTAG = "quantity";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >
                                                        ::UTAG = "unit";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >
                                                       ::VTAG = "value";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string Vector<Quantity<DIM, BT, UL, DU, ST> >
                                                        ::DTAG = "data";

//
//  the QuantityVector 
//


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


template<template<class, class, class> class M, 
  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 QuantityVector<M, 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 
      Vector<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> >
  {
      private:

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

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


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

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


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

      typedef Vector<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> > VEC;

    public:

      typedef ABQ PQ;


      typedef M<PQ, SU, DD> V;


      typedef ST StorageType;

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

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


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


        static const DD _defaultDD;


        DD _dedimensionalizer;

      std::vector<ST> _values;

    public:
      QuantityVector (void) {}


    template<class NU, class DD1>
      QuantityVector (const QuantityVector<M, PQ, NU, DD1> &new_vector) 
      {
        SU unit;
        int size = new_vector.size ();
        _values.reserve (size);

        for (int i = 0; i < size; i++)
          _values.push_back (new_vector[i].value (unit));
      }


      QuantityVector & operator= (const QuantityVector &new_vector)
      {
        if (this != &new_vector)
        {
          VEC::operator= (new_vector);
          _values = new_vector._values;
        }       

        return *this;
      }


    template<class NU, class DD1>
      QuantityVector & operator= 
                      (const QuantityVector<M, PQ, NU, DD1> &new_vector)
      {
        VEC::operator= (new_vector);

        SU unit;

        int size = new_vector.size ();

        _values.empty ();

        _values.reserve (size);

        for (int i = 0; i < size; i++)
          _values.push_back(new_vector[i].value (unit));

        return *this;
      }


    void save (BSUtilities::xmlw::XmlStream &os) const
    {
      os << BSUtilities::xmlw::tag (VEC::TAG)
         << BSUtilities::xmlw::attr (VEC::MTAG) << V::MODE
           << BSUtilities::xmlw::attr (VEC::QTAG) << PQ::Name ()
           << BSUtilities::xmlw::attr (VEC::UTAG) << SU::Name ();

      for (int i = 0; i < size (); i++)
         os << BSUtilities::xmlw::tag (VEC::DTAG) 
            << BSUtilities::xmlw::attr (VEC::VTAG) << _values[i] 
                                        << BSUtilities::xmlw::endtag ();

      os << BSUtilities::xmlw::endtag (VEC::TAG);
    }


    void load (const TiXmlHandle node)
    {
       TiXmlElement *element = node.Element();
        if (element
          && (element->ValueStr () == VEC::TAG)
                            && (element->Attribute(VEC::MTAG) == V::MODE))
        {
// load Quantity
// load unit
          TiXmlNode *child = 0;

          std::string value;

          while ((child = element->IterateChildren (VEC::DTAG, child)))
          {
            if ((child->ToElement ())->Attribute (VEC::VTAG))
            {
              value = (child->ToElement ())->Attribute (VEC::VTAG);
              _values.push_back 
                (BSUtilities::Conversion<ST>::string_to(value));
            }
          }
        }
        else
          throw LoadError
                    ("error loading Vector: incorrect element");

    }


      bool operator== 
        (const QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD> 
                                                          &vector) const
      {
        return ((size () == vector.size ()) 
                                          && (_values == vector._values));
      }


      int size (void) const {return _values.size ();}


      template<template<class, class, class> class Q1, class BT1, 
        class DIM1, class UL1, class DU1, class SU1, class ST1, 
                                                              class DD1>
        void push_back (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, 
                                                SU1, DD1> &new_quantity)
          {_values.push_back (Reverse<SU, ST>::VAL
            (Standardize<typename
              CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                        UL1, DU1, ST1>, SU1, DD1>::Unit,
              typename Loki::TL::Append<UL, unit::NonPrefixable<BT1, 
                    unit::GenericUnit> >::Result >::RET, ST>::VAL
                                             (new_quantity.value ())));}


      template<template<class, class, class> class Q1, class BT1, 
        class DIM1, class UL1, class DU1, class SU1, class ST1, 
                                                              class DD1>
        void insert (const Q1<Quantity<DIM1, BT1, UL1,
                    DU1, ST1>, SU1, DD1> &new_quantity, const int index)
          {if (index >= 0 && index < size ())
            {typename std::vector<ST>::iterator pos 
                                             = _values.begin () + index;
              _values.insert (pos, Reverse<SU, ST>::VAL
                (Standardize<typename
                   CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                        UL1, DU1, ST1>, SU1, DD1>::Unit,
                  typename Loki::TL::Append<UL,
                    unit::NonPrefixable<BT1, 
                        unit::GenericUnit> >::Result >::RET, ST>::VAL
                                              (new_quantity.value ())));
            }
          else
            {throw VectorOutOfBounds();}
        }                                                    


      template<template<class, class, class> class Q1, class BT1, 
        class DIM1, class UL1, class DU1, class SU1, class ST1, 
                                                              class DD1>
        void replace 
          (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, SU1, DD1> 
                                         &new_quantity, const int index)
          {if (index >= 0 && index < size ())
            {_values[index] = Reverse<SU, ST>::VAL
              (Standardize<typename
                CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                        UL1, DU1, ST1>, SU1, DD1>::Unit,
                typename Loki::TL::Append<UL,
                  unit::NonPrefixable<BT1,
                      unit::GenericUnit> >::Result >::RET, ST>::VAL
                                               (new_quantity.value ()));
            }
          else
            {throw VectorOutOfBounds();}
        }                                                    


    void erase (const int index)
    {
      if (index >= 0 && index < size ())
      {
        typename std::vector<ST>::iterator pos 
                                              = _values.begin () + index;
        _values.erase (pos);
      }
      else
      {throw VectorOutOfBounds();}
    }                                                    

    void clear (void) {_values.clear ();}


    std::vector<ST> values (void) {return _values;}   


      V value (const int index) const
        {if (index >= 0 && index < size ())
          {return V (_values[index]);}
         else
          {throw VectorOutOfBounds();}
        }                                                    


      V operator[] (const int index) const {return value (index);}


      template<class NU>
        M<Quantity<DIM, BT, UL, DU, ST>, NU, 
                           typename DefaultDedimensionalizer<PQ, NU>::F>
          value (const int index, const NU &unit) const
                                        {return (value (index))(unit);}


      V max (void) const
        {
          ST max_val = _values[0];
          typename std::vector<ST>::const_iterator index;

          for (index = _values.begin (); index < _values.end (); 
                                                                index++)
            max_val = ((max_val < *index) ? *index : max_val);
          
          return V (max_val);
        }


      template<class NU>
        M<Quantity<DIM, BT, UL, DU, ST>, NU, 
                           typename DefaultDedimensionalizer<PQ, NU>::F>
                    max (const NU &unit) const {return (max ()) (unit);}


      V min (void) const
        {
          ST min_val = _values[0];
          typename std::vector<ST>::const_iterator index;

          for (index = _values.begin (); index < _values.end (); 
                                                                index++)
            min_val = ((min_val < *index) ? min_val : *index);
          
          return V (min_val);
        }


      template<class NU>
        M<Quantity<DIM, BT, UL, DU, ST>, NU, 
                           typename DefaultDedimensionalizer<PQ, NU>::F>
                    min (const NU &unit) const {return (min ()) (unit);}

  };


template<class L> class QuantityVectorTuple;

//
//  helper classes and structs for the QuantityVector tuples
//


template<class TL> struct GetVar;


template<class Head, class Tail>
  struct GetVar<Loki::Typelist<Head, Tail> >
{
  private:
    typedef typename GetVar<Tail>::Result L1;

  public:
    typedef Loki::Typelist<typename Head::V, L1> Result;
};


template<>
  struct GetVar<Loki::NullType>
{
  typedef Loki::NullType Result;
};


template<int N, class L>
  class AddVal
  {
    public:
      static void addval (QuantityVectorTuple<L> &tuple, 
        const typename QuantityVectorTuple<L>::QTuple &new_values)
        {Loki::Field<N-1>(tuple.vectors).push_back 
                                         (Loki::Field<N-1>(new_values));
         AddVal<N-1, L>::addval (tuple, new_values);
        }

      static void addval (QuantityVectorTuple<L> &tuple, 
        const typename QuantityVectorTuple<L>::QTuple 
                                     &new_values, const int index)
        {Loki::Field<N-1>(tuple.vectors).insert 
                                  (Loki::Field<N-1>(new_values), index);
         AddVal<N-1, L>::addval (tuple, new_values, index);
        }
  };


template<class L>
  class AddVal<0, L>
  {
    public:
      static void addval (QuantityVectorTuple<L> &,
             const typename QuantityVectorTuple<L>::QTuple &) {};

      static void addval (QuantityVectorTuple<L> &,
        const typename QuantityVectorTuple<L>::QTuple &, const int) {};
  };


template<int N, class L>
  class EraVal
  {
    public:
      static void eraval (QuantityVectorTuple<L> &tuple, 
                                                        const int index)
        {Loki::Field<N-1>(tuple.vectors).erase (index);
         EraVal<N-1, L>::eraval (tuple, index);
        }
  };


template<class L>
  class EraVal<0, L>
  {
    public:
      static void eraval (QuantityVectorTuple<L> &, const int) {};
  };


template<int N, class L>
  class GetVal
  {
    public:
      static typename QuantityVectorTuple<L>::QTuple getval 
        (const QuantityVectorTuple<L> &tuple,
          typename QuantityVectorTuple<L>::QTuple 
                                               &values, const int index)
        {Loki::Field<N-1>(values) 
                               = Loki::Field<N-1>(tuple.vectors)[index];
         return GetVal<N-1, L>::getval (tuple, values, index);
        }
  };


template<class L>
  class GetVal<0, L>
  {
    public:
      static typename QuantityVectorTuple<L>::QTuple getval 
        (const QuantityVectorTuple<L> &,
          typename QuantityVectorTuple<L>::QTuple 
                              &values, const int) {return values;}
  };


template<int N, class L>
  class SaveVecType
  {
    public:
      static void saveVecType 
        (const QuantityVectorTuple<L> &tuple, 
                                       BSUtilities::xmlw::XmlStream &os)
      {
        os << BSUtilities::xmlw::attr 
             (QuantityVectorTuple<L>::MTAG
                          + BSUtilities::Conversion<int>::to_string (N))
           << Loki::TL::TypeAt<L, N-1>::Result::V::MODE
           << BSUtilities::xmlw::attr (QuantityVectorTuple<L>::QTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
           << Loki::TL::TypeAt<L, N-1>::Result::PQ::Name ()
           << BSUtilities::xmlw::attr (QuantityVectorTuple<L>::UTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                     << Loki::TL::TypeAt<L, N-1>::Result::Unit::Name ();
        SaveVecType<N-1, L>::saveVecType (tuple, os);
      }
  };


template<class L>
  class SaveVecType<0, L>
  {
    public:
      static void saveVecType 
        (const QuantityVectorTuple<L> &, 
                                      BSUtilities::xmlw::XmlStream &) {}
  };


template<int N, class L>
  class SaveVec
  {
    public:
      static void saveVec 
        (const QuantityVectorTuple<L> &tuple, int index,
                                       BSUtilities::xmlw::XmlStream &os)
      {
        os << BSUtilities::xmlw::attr (QuantityVectorTuple<L>::VTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
           << Loki::Field<N-1>(tuple.vectors)[index].value ();
        SaveVec<N-1, L>::saveVec (tuple, index, os);
      }
  };



template<class L>
  class SaveVec<0, L>
  {
    public:
      static void saveVec 
        (const QuantityVectorTuple<L> &, int, 
                                      BSUtilities::xmlw::XmlStream &) {}
  };


template<int N, class L>
  class CheckQuantities
  {
    public:
      static bool checkQuantities
        (const QuantityVectorTuple<L> &tuple, 
                                            const TiXmlElement *element)
      {
        if ((element->Attribute (QuantityVectorTuple<L>::QTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                       == Loki::TL::TypeAt<L, N-1>::Result::PQ::Name ())
          && (element->Attribute (QuantityVectorTuple<L>::UTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                    == Loki::TL::TypeAt<L, N-1>::Result::Unit::Name ())
          && (element->Attribute (QuantityVectorTuple<L>::MTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                          == Loki::TL::TypeAt<L, N-1>::Result::V::MODE))
          {return CheckQuantities<N-1, L>::checkQuantities 
                                                      (tuple, element);}

        else
          return false;
      }
  };


template<class L>
  class CheckQuantities<0, L>
  {
    public:
      static bool checkQuantities 
        (const QuantityVectorTuple<L> &, const TiXmlElement *) 
                                                          {return true;}
  };


template<int N, class L>
  class LoadVec
  {
    public:
      static void loadvec 
        (QuantityVectorTuple<L> &tuple, const TiXmlNode *child)
      {
        const TiXmlElement *element = child->ToElement();

        if (element->Attribute 
          (QuantityVectorTuple<L>::VTAG 
                         + BSUtilities::Conversion<int>::to_string (N)))
        {
// check quantity type and skip if Empty!!!!!!!!!
// also: read mode from MTAG
          Loki::Field<N-1>(tuple.vectors).push_back 
            (typename Loki::TL::TypeAt<L, N-1>::Result::V
              (BSUtilities::Conversion<typename Loki::TL::TypeAt<L, N-1>
                ::Result::StorageType>::string_to
                  (element->Attribute (QuantityVectorTuple<L>::VTAG 
                      + BSUtilities::Conversion<int>::to_string (N)))));
          LoadVec<N-1, L>::loadvec (tuple, child);
        }

        else
          throw LoadError 
                ("error loading QuantityVectorTuple: incorrect vector");

      }
  };


template<class L>
  class LoadVec<0, L>
  {
    public:
      static void loadvec (QuantityVectorTuple<L> &, const TiXmlNode *)
                                                                      {}
  };


template<int N, class L>
  class CmpVec
  {
    public:
      static bool cmpVec
        (const QuantityVectorTuple<L> &tuple1, 
                                   const QuantityVectorTuple<L> &tuple2)
      {
        if (Loki::Field<N-1>(tuple1.vectors) 
                                    == Loki::Field<N-1>(tuple2.vectors))
          return CmpVec<N-1, L>::cmpVec (tuple1, tuple2);

        else
          return false;
      }
  };


template<class L>
  class CmpVec<0, L>
  {
    public:
      static bool cmpVec 
        (const QuantityVectorTuple<L> &, const QuantityVectorTuple<L> &)
                                                          {return true;}
  };

/* primary template
*/
template <class V, class QVT> struct CheckVariableInVectorTuple;


template<template<class, class, class> class T, class V, class DIM, 
  class BT, class UL, class DU, class ST, class SU,  class DD, 
                                                            class LTail>
  struct CheckVariableInVectorTuple<V,
    Loki::Typelist<QuantityVector<T, Quantity <DIM, BT, UL, DU, ST>, 
                                                       SU, DD>, LTail> >
  {
    private:
      typedef typename BSUtilities::IF<BSUtilities::SameType<V,
        typename QuantityVector<T, Quantity<DIM, BT, UL, DU, ST>, 
                                                  SU, DD>::V>::sameType,
          QuantityVector<T, Quantity<DIM, BT, UL, DU, ST>, SU, DD>,
           typename CheckVariableInVectorTuple<V, LTail>::RET>::RET RET;
  };


template<class V>
  struct CheckVariableInVectorTuple<V, Loki::NullType>
  {
    typedef VariableError<true> RET;
  };

//
//  the QuantityVector tuple
//


template<template<class, class, class> class T, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  class QuantityVectorTuple<Loki::Typelist<
      QuantityVector<T, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
  {
  private:
    typedef Loki::Typelist<QuantityVector<T, 
                       Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> L;

    Loki::Tuple<L> vectors;

  public:

    typedef Loki::Tuple<typename GetVar<L>::Result> QTuple;


    void save (BSUtilities::xmlw::XmlStream &os) const
    {
      os << BSUtilities::xmlw::tag (TAG);

      SaveVecType<Loki::TL::Length<L>::value, L>::saveVecType 
                                                            (*this, os);

      for (int index = 0; index < size (); index++)
      {
        os << BSUtilities::xmlw::tag (QuantityVectorTuple<L>::DTAG);
        SaveVec<Loki::TL::Length<L>::value, L>::saveVec 
                                                     (*this, index, os);
        os << BSUtilities::xmlw::endtag (DTAG);
      }

      os << BSUtilities::xmlw::endtag (TAG);
    }


    void load (const TiXmlHandle node)
    {
       TiXmlElement *element = node.Element();
        if (element && (element->ValueStr () == TAG))
        {
          if(CheckQuantities<Loki::TL::Length<L>::value, L>
                                     ::checkQuantities (*this, element))
          {
            TiXmlNode *child = 0;
            
            TiXmlElement *element = node.Element();

            while ((child = element->IterateChildren (DTAG, child)))
              {LoadVec<Loki::TL::Length<L>::value, L>::loadvec 
                                                        (*this, child);}
          }

          else
            throw LoadError
              ("error loading QuantityVectorTuple: "
                                                "incorrect attributes");
        }

        else
          throw LoadError
            ("error loading QuantityVectorTuple: incorrect element");

    }


      bool operator== (const QuantityVectorTuple &tuple) const
        {return CmpVec<Loki::TL::Length<L>::value, L>::cmpVec 
                                                        (*this, tuple);}

    int number (void) const {return Loki::TL::Length<L>::value;}

/*  all vectors have the same size, return value determined from
    first vector.
*/
    int size (void) const {return Loki::Field<0>(vectors).size ();}


/*  uses data from a QTuple; uses helper class AddVal.
*/
    void push_back (const QTuple &new_values)
    {
      AddVal<Loki::TL::Length<L>::value, L>::addval (*this, new_values);
    }

/*  uses data from a QTuple; uses helper class AddVal.
*/
    void insert (const QTuple &new_values, const int index)
    {
      AddVal<Loki::TL::Length<L>::value, L>::addval 
                                             (*this, new_values, index);
    }


    void erase (const int index)
    {
      EraVal<Loki::TL::Length<L>::value, L>::eraval (*this, index);
    }


    template<int I>
      typename Loki::TL::TypeAt<L, I>::Result::V 
                                  value (const unsigned int index) const
                      {return (Loki::Field<I>((*this).vectors))[index];}


    template<int I, class NU>
      T<typename Loki::TL::TypeAt<L, I>::Result::V::PQ, NU, 
                         typename Loki::TL::TypeAt<L, I>::Result::V::DD>
        value (const int index, const NU &unit) const
          {return 
               ((Loki::Field<I>((*this).vectors)).value (index))(unit);}


    QTuple operator[] (const int index) const
    {
      QTuple values;
      return GetVal<Loki::TL::Length<L>::value, L>::getval 
                                                 (*this, values, index);
    }


    QTuple values (const int index) const {return (*this)[index];}

    template<int I>
      QuantityVector<T, typename Loki::TL::TypeAt<L, I>::Result::V::PQ,
        typename Loki::TL::TypeAt<L, I>::Result::V::Unit, 
          typename Loki::TL::TypeAt<L, I>::Result::V::DD>
                                     getVector (Loki::Int2Type<I>) const
      {return QuantityVector<T, 
        typename Loki::TL::TypeAt<L, I>::Result::V::PQ,
          typename Loki::TL::TypeAt<L, I>::Result::V::Unit, 
            typename Loki::TL::TypeAt<L, I>::Result::V::DD> 
                                     (Loki::Field<I>((*this).vectors));}

    template<int N, class L1> friend class AddVal;
     
    template<int N, class L1> friend class GetVal;
     
    template<int N, class L1> friend class EraVal;
     
    template<int N, class L1> friend class SaveVec;
     
    template<int N, class L1> friend class CmpVec;
     
    template<int N, class L1> friend class LoadVec;
     
    template<int N, class L1> friend class Copy;
     
    template<int N, class L1> friend class Assign;

      static const std::string TAG;
     
      static const std::string QTAG;
     
      static const std::string UTAG;
     
      static const std::string DTAG;
     
      static const std::string VTAG;
     
      static const std::string MTAG;
     
  };

template<template<class, class, class> class M, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                          ::TAG = "quantityVectorTuple";

template<template<class, class, class> class M, class DIM, class BT, 
           class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                                    ::QTAG = "quantity";

template<template<class, class, class> class M, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                                        ::UTAG = "unit";

template<template<class, class, class> class M, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                                        ::DTAG = "data";

template<template<class, class, class> class M, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                                       ::VTAG = "value";

template<template<class, class, class> class M, class DIM, class BT, 
          class UL, class DU, class ST, class SU, class DD, class LTail>
  const std::string 
    QuantityVectorTuple<Loki::Typelist<
      QuantityVector<M, Quantity<DIM, BT, UL, DU, ST>, SU, DD>, LTail> >
                                                       ::MTAG = "mode";

}


#endif /* _QuantityCluster */

---