Quantity.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 _Quantity_h
#define _Quantity_h

#include "Quantity/Unit.h"
#include "Quantity/Dimension.h"

#include "BSUtilities.h"
#include "Conversion.h"

#include "Singleton.h"
#include "NullType.h"

#include <iostream>
#include <string>

namespace Quantities {

//
//  Helper classes and structs which store and/or check 
//  specific units or lists of units.
//


class UnitMismatch {};


class InputError {};


template<class GT, class UL, class DU, class ST = double>
  class FindBySymbol
  {
    public:
      static Units::Unit<GT, ST> *result (const std::string &unitstring)
        {if (UL::Head::Symbol () == unitstring)
           return new typename UL::Head;
         else
           return FindBySymbol<GT, 
                       typename UL::Tail, DU, ST>::result (unitstring);
        }
  };


template<class GT, class DU, class ST>
  class FindBySymbol<GT, Loki::NullType, DU, ST>
  {
    public:

      static Units::Unit<GT, ST> *result (const std::string &)
        {throw UnitMismatch (); return 0;}
  };



template<class GT, class UL, class ST = double>
  class ListUnitSymbols
  {
    public:

    static std::vector<std::string> & result 
                                (std::vector<std::string> &stringvector)
      {
       stringvector.push_back (UL::Head::Symbol ());
       return ListUnitSymbols<GT, typename UL::Tail, ST>::result 
                                                         (stringvector);
      }
  };


template<class GT, class ST>
  class ListUnitSymbols<GT, Loki::NullType, ST>
  {
    public:
    static std::vector<std::string> & result 
                                (std::vector<std::string> &stringvector)
      {
        return stringvector;
      }
  };

template<class GT, class UL, class DU, class ST = double>
  class AllUnits
  {
    private:

      typedef 
        typename Units::CheckUnits<Units::Unit<GT, ST>, UL>::Checked 
                                                                Checked;

    public:
      typedef UL Units;


      static ::Units::Unit<GT, ST> *unit (const std::string &unitstring)
        {return FindBySymbol<GT, UL, DU, ST>::result (unitstring);}


      static std::vector<std::string> allsymbols (void)
        {std::vector<std::string> stringvector;
         return ListUnitSymbols<GT, UL, ST>::result (stringvector);
        }
  };


template<class GT, class U, class ST = double>
  class DefaultUnit
  {
    private:

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

    public:
      typedef U Unit;
  };


template<bool>
  struct DimensionError;


template<>
  struct DimensionError<false>
    {

       static const bool RET = true;
    };


template<class Q>
  struct CheckDimensionality
  {
    public: 

      static const bool RET =
        BSUtilities::IF<Q::D::IsDimensionless, DimensionError<false>, 
                                       DimensionError<true> >::RET::RET;
  };

template<class U, class TL> struct CheckAgainstAllUnits;


template<class U, class Head, class Tail> 
  struct CheckAgainstAllUnits<U, Loki::Typelist<Head, Tail> >
  {
    typedef 
      typename BSUtilities::IF<BSUtilities::SameType<U, Head>::sameType,
              U, typename CheckAgainstAllUnits<U, Tail>::RET >::RET RET;
  };


template<class U>
  struct CheckAgainstAllUnits<U, Loki::NullType>
  {
    typedef Units::UnitError<true> RET;
  };
  
//
//  helper classes for input and output
//


template<bool P> class PrintName;

template<bool P> class PrintSymbol;

class PrintStatus
  {
    private:
      static bool _name;
      static bool _symbol;

    public:

      bool name (void) const {return _name;}

      bool symbol (void) const {return _symbol;}

      template<bool P> friend class PrintName;

      template<bool P> friend class PrintSymbol;
  };

typedef Loki::SingletonHolder<PrintStatus> PrintStatusHolder;

#define PS PrintStatusHolder::Instance()


template<bool P>
  class PrintName
  {

    void set (bool name) const {PrintStatus::_name = name;}


    friend std::ostream & operator<< 
                              (std::ostream &os, const PrintName &print)
           {print.set (P); return os;}
  };


template<bool P>
  class PrintSymbol
  {

    void set (bool symbol) const {PrintStatus::_symbol = symbol;}


    friend std::ostream & operator<< 
                           (std::ostream &os, const PrintSymbol &print)
           {print.set (P); return os;}

  };


template<bool P> class ReadName;


template<bool P> class ReadSymbol;


template<bool P> class ReadEqual;

class ReadStatus
  {
    private:
      static bool _name;

      static bool _symbol;

      static bool _equal;


      static std::string _unit;

    public:

      bool name (void) const {return _name;}


      bool symbol (void) const {return _symbol;}


      bool equal (void) const {return _equal;}


      std::string unit (void) const {return _unit;}

      template<bool P> friend class ReadName;

      template<bool P> friend class ReadSymbol;

      template<bool P> friend class ReadEqual;

      template<class U> friend class ReadUnit;
  };

typedef Loki::SingletonHolder<ReadStatus> ReadStatusHolder;

#define RS ReadStatusHolder::Instance()


template<bool P>
  class ReadName
  {

    void set (bool name) const {ReadStatus::_name = name;}


    friend std::istream & operator>> 
                              (std::istream &is, const ReadName &read)
           {read.set (P); return is;}
  };


template<bool P>
  class ReadSymbol
  {

    void set (bool symbol) const {ReadStatus::_symbol = symbol;}


    friend std::istream & operator>> 
                           (std::istream &is, const ReadSymbol &read)
           {read.set (P); return is;}

  };


template<bool P>
  class ReadEqual
  {

    void set (bool equal) const {ReadStatus::_equal = equal;}


    friend std::istream & operator>> 
                              (std::istream &is, const ReadEqual &read)
           {read.set (P); return is;}

  };


template<class U>
  class ReadUnit
  {

    void set (std::string unit) const {ReadStatus::_unit = unit;}


    friend std::istream & operator>> 
                           (std::istream &is, const ReadUnit<U> &unit)
           {unit.set (U::Symbol ()); return is;}

  };

typedef Loki::NullType NoUnit;


template<>
  class ReadUnit<NoUnit>
  {

    void set (std::string unit) const {ReadStatus::_unit = unit;}


    friend std::istream & operator>> 
                      (std::istream &is, const ReadUnit<NoUnit> &unit)
           {unit.set (""); return is;}

  };


//
//  the Quantities base class
//


class Quantities
  {
    public:

      static std::string version (void)
        {static const 
          std::string v_string ("Quantities version 1.0 with ");
             return v_string + ::Units::Units::version () + ", " 
                   + ::Dimensions::Dimensions::version () + 
                       " and " + ::BSUtilities::version ();}


      virtual const std::string unitsymbol (void) const = 0;


      virtual const std::string unitname (void) const = 0;


      virtual const bool isDimensionless (void) const = 0;


      virtual ~Quantities (void) {}

  };

//
//  the Quantity base class
//


template<class GT, class UL, class DU, class ST = double> 
                                                         class Quantity;

template <class Q> struct Name;

template<class GT, class Head, class Tail, class DU, class ST>
  struct Name<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> >
  {

    static const std::string String;
  };

template <class Q> struct Symbol;

template<class GT, class Head, class Tail, class DU, class ST>
  struct Symbol<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> >
  {

    static const std::string String;
  };


template<class GT, class Head, class Tail, class DU, class ST>
  class Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> 
                                                     : public Quantities
  {
    private:
      typedef 
           Name<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> > Name;
      typedef Symbol<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> > 
                                                                 Symbol;

    public:

      typedef Dimensions::Dimension<GT> D;

      typedef GT Type;

      typedef ST SType;

    protected:

      std::string namestring;

      std::string symbolstring;


      Units::Unit<GT, ST> * findBySymbol (const std::string &unitsymbol)
         {return FindBySymbol<GT, Loki::Typelist<Head, Tail>, DU, ST>
                                                 ::result (unitsymbol);}

    public:

      Quantity (void) 
         : namestring (Name::String), symbolstring (Symbol::String) {}


      virtual ~Quantity (void) {}


      typedef AllUnits<GT, Loki::Typelist<Head, Tail>, ST> AllUnits;


      typedef DefaultUnit<GT, DU, ST> DefaultUnit;

      std::string name (void) const {return namestring;}
      std::string symbol (void) const {return symbolstring;}

      void name (const std::string &name) {namestring = name;}
      void symbol (const std::string &symbol) {symbolstring = symbol;}


      virtual ST standard_value (void) const = 0;


      virtual ST value (void) const = 0;


      static const bool IsDimensionless = D::IsDimensionless;


      const bool isDimensionless (void) const {return IsDimensionless;}


      struct Dummy;


      struct Exp {static ST exec (const Quantity &quantity) 
                              {return ST(std::exp (quantity.value ()));}
                 };


      friend ST exp (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Exp, Dummy>::RET::exec (quantity));
        }


      struct Log {static ST exec (const Quantity &quantity) 
                     {return ST(std::log (quantity.value ()));}
                 };


      friend ST log (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Log, Dummy>::RET::exec (quantity));
        }


      struct Log10 {static ST exec (const Quantity &quantity) 
                            {return ST(std::log10 (quantity.value ()));}
                 };


      friend ST log10 (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Log10, Dummy>::RET::exec (quantity));
        }


      struct Sin {static ST exec (const Quantity &quantity) 
                              {return ST(std::sin (quantity.value ()));}
                 };


      friend ST sin (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Sin, Dummy>::RET::exec (quantity));
        }


      struct Cos {static ST exec (const Quantity &quantity) 
                              {return ST(std::cos (quantity.value ()));}
                 };


      friend ST cos (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Cos, Dummy>::RET::exec (quantity));
        }


      struct Tan {static ST exec (const Quantity &quantity) 
                              {return ST(std::tan (quantity.value ()));}
                 };


      friend ST tan (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Tan, Dummy>::RET::exec (quantity));
        }


      struct Sinh {static ST exec (const Quantity &quantity) 
                             {return ST(std::sinh (quantity.value ()));}
                 };


      friend ST sinh (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Sinh, Dummy>::RET::exec (quantity));
        }


      struct Cosh {static ST exec (const Quantity &quantity) 
                             {return ST(std::cosh (quantity.value ()));}
                 };


      friend ST cosh (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Cosh, Dummy>::RET::exec (quantity));
        }


      struct Tanh {static ST exec (const Quantity &quantity) 
                             {return ST(std::tanh (quantity.value ()));}
                 };


      friend ST tanh (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Tanh, Dummy>::RET::exec (quantity));
        }


      struct Asin {static ST exec (const Quantity &quantity) 
                             {return ST(std::asin (quantity.value ()));}
                 };


      friend ST asin (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Asin, Dummy>::RET::exec (quantity));
        }


      struct Acos {static ST exec (const Quantity &quantity) 
                             {return ST(std::acos (quantity.value ()));}
                 };


      friend ST acos (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Acos, Dummy>::RET::exec (quantity));
        }


      struct Atan {static ST exec (const Quantity &quantity) 
                             {return ST(std::atan (quantity.value ()));}
                 };


      friend ST atan (const Quantity &quantity)
        {
          return ST(BSUtilities::IF<CheckDimensionality<Quantity>::RET,
                      Atan, Dummy>::RET::exec (quantity));
        }


      struct Atan2 {static ST exec 
                  (const Quantity &quantity, const Quantity & quantity2)
        {return ST(std::atan2 
            (quantity.standard_value (), quantity2.standard_value ()));}
        };


      friend ST atan2 
        (const Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> 
                                                              &quantity,
           const Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> 
                                                             &quantity2)
        {return ST(Atan2::exec (quantity, quantity2));}


      friend std::ostream & operator<< 
                            (std::ostream &os, const Quantity &quantity)
             {return quantity.print (os);}


      std::ostream & print (std::ostream &os) const
        {
          std::string name (""); 
          std::string symbol ("");
          std::string equal ("");

          if (PS.name ())
            name = namestring + " ";

          if (PS.symbol ())
            symbol = symbolstring + " ";

          if (PS.name () || PS.symbol ())
            equal = "= ";

          os << name << symbol << equal;

          return print_value (os);
        }


      virtual std::ostream & print_value (std::ostream &os) const = 0;

      friend void operator<< 
        (std::string &str, const Quantity &quantity) {quantity >> str;}

      virtual void operator>> (std::string &str) const = 0;


      operator std::string () const 
        {std::string string; *this >> string; return string;}

      virtual std::ostream & operator>> (std::ostream &os) const = 0;

  };

//
//  helper classes which use the Quantity template
//


template<class Q1, class Q2> struct SameDimensioned;


template<template<class, class> class Q1, class GT1, class Head1, 
           class Tail1, class DU1, class U1, class ST1,
         template<class, class> class Q2, class GT2, class Head2, 
           class Tail2, class DU2, class U2, class ST2>
  struct SameDimensioned
    <Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST1>, U1>, 
         Q2<Quantity<GT2, Loki::Typelist<Head2, Tail2>, DU2, ST2>, U2> >
  {
    enum {RET 
      = Dimensions::Equal<Dimensions::Dimension<GT1>, 
                                     Dimensions::Dimension<GT2> >::RET};
  };


template<class Q1, class Q2> struct CheckSecondDimension;

template<template<class, class> class Q1, class GT1, class Head1, 
           class Tail1, class DU1, class U1, class ST1,
         template<class, class> class Q2, class GT2, class Head2, 
           class Tail2, class DU2, class U2, class ST2>
  struct CheckSecondDimension
    <Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST1>, U1>, 
         Q2<Quantity<GT2, Loki::Typelist<Head2, Tail2>, DU2, ST2>, U2> >
  {
    private:
      typedef 
        Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, DU1, ST1>, U1> 
                                                                 Quant1;
      typedef 
        Q2<Quantity<GT2, Loki::Typelist<Head2, Tail2>, DU2, ST2>, U2> 
                                                                 Quant2;

    public:
      typedef 
        typename BSUtilities::IF<SameDimensioned<Quant1, Quant2>::RET, 
                                Quant2, DimensionError<true> >::RET RET;
  };

}

#endif /* _Quantity_h */

---