Dimension.h

Go to the documentation of this file.

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

#include <string>

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

// BSUtilities includes
#include "BSUtilities/TemplateTools.h"

namespace dimension {

//
//  Helper classes and structs for manipulation of dimensions and
//  lists of Rational numbers coding dimensions
//


template<class DL> struct Dimensionality;


template<class Head, class Tail>
  struct Dimensionality<Loki::Typelist<Head, Tail> >
  {

    enum {IsDimensionless = 
            ((Head::numerator == 0) && 
               (Dimensionality<Tail>::IsDimensionless == 1)) ? 1 : 0};
  };


template<>
  struct Dimensionality<Loki::NullType>
  {
    enum {IsDimensionless = 1};
  };


template<class DL1, class DL2> struct DimensionEquality;


template<class DL1Head, class DL2Head, class DL1Tail, class DL2Tail> 
  struct DimensionEquality<Loki::Typelist<DL1Head, DL1Tail>, 
                                      Loki::Typelist<DL2Head, DL2Tail> >
  {

    enum {EQ = (BSUtilities::RationalEquality<DL1Head, DL2Head>::RET
                   && DimensionEquality<DL1Tail, DL2Tail>::EQ) ? 1 : 0};
  };


template<class DL1Head, class DL2Head> 
  struct DimensionEquality<Loki::Typelist<DL1Head, Loki::NullType>, 
                               Loki::Typelist<DL2Head, Loki::NullType> >
  {

    enum {EQ = BSUtilities::RationalEquality<DL1Head, DL2Head>::RET};
  };

//
//  the Dimension of a quantity
//


template 
  <typename RL, typename RM, typename RT, typename RE, typename RTE, 
                                   typename RA, typename RLU> class Dimension;


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 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> >
  {
    public:
      typedef 
        Loki::Typelist<BSUtilities::Rational<RL_N, RL_D>,
          Loki::Typelist<BSUtilities::Rational<RM_N, RM_D>,
            Loki::Typelist<BSUtilities::Rational<RT_N, RT_D>,
              Loki::Typelist<BSUtilities::Rational<RE_N, RE_D>,
                Loki::Typelist<BSUtilities::Rational<RTE_N, RTE_D>,
                  Loki::Typelist<BSUtilities::Rational<RA_N, RA_D>,
                    Loki::Typelist<BSUtilities::Rational<RLU_N, RLU_D>, 
                                    Loki::NullType> > > > > > > DimList;

      typedef BSUtilities::Rational<RL_N, RL_D> RL;
      typedef BSUtilities::Rational<RM_N, RM_D> RM;
      typedef BSUtilities::Rational<RT_N, RT_D> RT;
      typedef BSUtilities::Rational<RE_N, RE_D> RE;
      typedef BSUtilities::Rational<RTE_N, RTE_D> RTE;
      typedef BSUtilities::Rational<RA_N, RA_D> RA;
      typedef BSUtilities::Rational<RLU_N, RLU_D> RLU;

      typedef typename BSUtilities::Rational<RL_N, RL_D>::Canonical canonicalRL;
      typedef typename BSUtilities::Rational<RM_N, RM_D>::Canonical canonicalRM;
      typedef typename BSUtilities::Rational<RT_N, RT_D>::Canonical canonicalRT;
      typedef typename BSUtilities::Rational<RE_N, RE_D>::Canonical canonicalRE;
      typedef typename BSUtilities::Rational<RTE_N, RTE_D>::Canonical canonicalRTE;
      typedef typename BSUtilities::Rational<RA_N, RA_D>::Canonical canonicalRA;
      typedef typename BSUtilities::Rational<RLU_N, RLU_D>::Canonical canonicalRLU;

      static long const numRL = BSUtilities::Rational<RL_N, RL_D>::numerator;
      static long const numRM = BSUtilities::Rational<RM_N, RM_D>::numerator;
      static long const numRT = BSUtilities::Rational<RT_N, RT_D>::numerator;
      static long const numRE = BSUtilities::Rational<RE_N, RE_D>::numerator;
      static long const numRTE = BSUtilities::Rational<RTE_N, RTE_D>::numerator;
      static long const numRA = BSUtilities::Rational<RA_N, RA_D>::numerator;
      static long const numRLU = BSUtilities::Rational<RLU_N, RLU_D>::numerator;

      static long const canonicalNumRL =  BSUtilities::Rational<RL_N, RL_D>::Canonical::numerator;
      static long const canonicalNumRM = BSUtilities::Rational<RM_N, RM_D>::Canonical::numerator;
      static long const canonicalNumRT = BSUtilities::Rational<RT_N, RT_D>::Canonical::numerator;
      static long const canonicalNumRE = BSUtilities::Rational<RE_N, RE_D>::Canonical::numerator;
      static long const canonicalNumRTE = BSUtilities::Rational<RTE_N, RTE_D>::Canonical::numerator;
      static long const canonicalNumRA = BSUtilities::Rational<RA_N, RA_D>::Canonical::numerator;
      static long const canonicalNumRLU = BSUtilities::Rational<RLU_N, RLU_D>::Canonical::numerator;

      static long const denomRL = BSUtilities::Rational<RL_N, RL_D>::denominator;
      static long const denomRM = BSUtilities::Rational<RM_N, RM_D>::denominator;
      static long const denomRT = BSUtilities::Rational<RT_N, RT_D>::denominator;
      static long const denomRE = BSUtilities::Rational<RE_N, RE_D>::denominator;
      static long const denomRTE = BSUtilities::Rational<RTE_N, RTE_D>::denominator;
      static long const denomRA = BSUtilities::Rational<RA_N, RA_D>::denominator;
      static long const denomRLU = BSUtilities::Rational<RLU_N, RLU_D>::denominator;

      static long const canonicalDenomRL = BSUtilities::Rational<RL_N, RL_D>::Canonical::denominator;
      static long const canonicalDenomRM = BSUtilities::Rational<RM_N, RM_D>::Canonical::denominator;
      static long const canonicalDenomRT = BSUtilities::Rational<RT_N, RT_D>::Canonical::denominator;
      static long const canonicalDenomRE = BSUtilities::Rational<RE_N, RE_D>::Canonical::denominator;
      static long const canonicalDenomRTE = BSUtilities::Rational<RTE_N, RTE_D>::Canonical::denominator;
      static long const canonicalDenomRA = BSUtilities::Rational<RA_N, RA_D>::Canonical::denominator;
      static long const canonicalDenomRLU = BSUtilities::Rational<RLU_N, RLU_D>::Canonical::denominator;


      static const bool IsDimensionless 
                               = Dimensionality<DimList>::IsDimensionless;


      static bool isDimensionless (void) {return IsDimensionless;}


    template<class D1> struct Add;


    template<long RL1_N, long RL1_D, long RM1_N, long RM1_D, 
      long RT1_N, long RT1_D, long RE1_N, long RE1_D, 
        long RTE1_N, long RTE1_D, long RA1_N, long RA1_D, 
                                               long RLU1_N, long RLU1_D>
      struct Add<Dimension<BSUtilities::Rational<RL1_N, RL1_D>, 
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>, 
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                               BSUtilities::Rational<RLU1_N, RLU1_D> > >
      {
        private:
          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RL_N, RL_D>, 
                          BSUtilities::Rational<RL1_N, RL1_D> >::RET A0;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RM_N, RM_D>, 
                          BSUtilities::Rational<RM1_N, RM1_D> >::RET A1;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RT_N, RT_D>, 
                          BSUtilities::Rational<RT1_N, RT1_D> >::RET A2;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RE_N, RE_D>, 
                          BSUtilities::Rational<RE1_N, RE1_D> >::RET A3;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RTE_N, RTE_D>, 
                        BSUtilities::Rational<RTE1_N, RTE1_D> >::RET A4;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RA_N, RA_D>, 
                          BSUtilities::Rational<RA1_N, RA1_D> >::RET A5;

          typedef typename BSUtilities::RationalAdd<
            BSUtilities::Rational<RLU_N, RLU_D>, 
                        BSUtilities::Rational<RLU1_N, RLU1_D> >::RET A6;

        public:

          typedef Dimension<A0, A1, A2, A3, A4, A5, A6> Res;         

      };


    template<class D1> struct Sub;


    template<long RL1_N, long RL1_D, long RM1_N, long RM1_D, 
      long RT1_N, long RT1_D, long RE1_N, long RE1_D, 
        long RTE1_N, long RTE1_D, long RA1_N, long RA1_D, 
                                               long RLU1_N, long RLU1_D>
      struct Sub<Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                               BSUtilities::Rational<RLU1_N, RLU1_D> > >
      {
        private:
          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RL_N, RL_D>, 
                          BSUtilities::Rational<RL1_N, RL1_D> >::RET A0;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RM_N, RM_D>, 
                          BSUtilities::Rational<RM1_N, RM1_D> >::RET A1;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RT_N, RT_D>, 
                          BSUtilities::Rational<RT1_N, RT1_D> >::RET A2;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RE_N, RE_D>, 
                          BSUtilities::Rational<RE1_N, RE1_D> >::RET A3;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RTE_N, RTE_D>, 
                        BSUtilities::Rational<RTE1_N, RTE1_D> >::RET A4;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RA_N, RA_D>, 
                          BSUtilities::Rational<RA1_N, RA1_D> >::RET A5;

          typedef typename BSUtilities::RationalSub<
            BSUtilities::Rational<RLU_N, RLU_D>, 
                        BSUtilities::Rational<RLU1_N, RLU1_D> >::RET A6;

        public:

          typedef Dimension<A0, A1, A2, A3, A4, A5, A6> Res;         
    };


    template<long N, long D>
      struct Mult
      {
        private:
          typedef typename BSUtilities::RationalMult<
            BSUtilities::Rational<RL_N, RL_D>,
                                  BSUtilities::Rational<N, D> >::RET A0;

          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RM_N, RM_D>,
                                  BSUtilities::Rational<N, D> >::RET A1;

          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RT_N, RT_D>,
                                  BSUtilities::Rational<N, D> >::RET A2;

          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RE_N, RE_D>,
                                  BSUtilities::Rational<N, D> >::RET A3;

          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RTE_N, RTE_D>,
                                  BSUtilities::Rational<N, D> >::RET A4;

          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RA_N, RA_D>,
                                  BSUtilities::Rational<N, D> >::RET A5;
          typedef typename BSUtilities::RationalMult< 
            BSUtilities::Rational<RLU_N, RLU_D>,
                                  BSUtilities::Rational<N, D> >::RET A6;

        public:

          typedef Dimension<A0, A1, A2, A3, A4, A5, A6> Res;         
    };


    struct Inv
    {
      private:
        typedef typename BSUtilities::RationalNeg< 
                            BSUtilities::Rational<RL_N, RL_D> >::RET A0;

        typedef typename BSUtilities::RationalNeg< 
                            BSUtilities::Rational<RM_N, RM_D> >::RET A1;

        typedef typename BSUtilities::RationalNeg< 
                            BSUtilities::Rational<RT_N, RT_D> >::RET A2;

        typedef typename BSUtilities::RationalNeg< 
                            BSUtilities::Rational<RE_N, RE_D> >::RET A3;

        typedef typename BSUtilities::RationalNeg< 
                          BSUtilities::Rational<RTE_N, RTE_D> >::RET A4;

        typedef typename BSUtilities::RationalNeg< 
                            BSUtilities::Rational<RA_N, RA_D> >::RET A5;

        typedef typename BSUtilities::RationalNeg< 
                          BSUtilities::Rational<RLU_N, RLU_D> >::RET A6;

      public:

        typedef Dimension<A0, A1, A2, A3, A4, A5, A6> Res;         
    };


template<typename D1> struct Equal;


  template<long RL1_N, long RL1_D, long RM1_N, long RM1_D, 
      long RT1_N, long RT1_D, long RE1_N, long RE1_D, 
        long RTE1_N, long RTE1_D, long RA1_N, long RA1_D, 
                                               long RLU1_N, long RLU1_D>
      struct Equal<Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
        BSUtilities::Rational<RM1_N, RM1_D>,
          BSUtilities::Rational<RT1_N, RT1_D>,
            BSUtilities::Rational<RE1_N, RE1_D>,
              BSUtilities::Rational<RTE1_N, RTE1_D>,
                BSUtilities::Rational<RA1_N, RA1_D>,
                               BSUtilities::Rational<RLU1_N, RLU1_D> > >
      {

        enum {EQ = DimensionEquality<typename
          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> >::DimList, 
            typename Dimension<BSUtilities::Rational<RL1_N, RL1_D>, 
              BSUtilities::Rational<RM1_N, RM1_D>, 
                BSUtilities::Rational<RT1_N, RT1_D>, 
                  BSUtilities::Rational<RE1_N, RE1_D>, 
                    BSUtilities::Rational<RTE1_N, RTE1_D>, 
                      BSUtilities::Rational<RA1_N, RA1_D>, 
                    BSUtilities::Rational<RLU1_N, RLU1_D> >::DimList>::EQ};
       };
  };
}

#endif /* _Dimension_h */

---