Constant.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 _Constant_h
#define _Constant_h

// Quantity includes
#include "Quantity/Quantity.h"
#include "Quantity/QuantityError.h"
#include "Quantity/Variable.h"

// BOOST includes
#include <boost/serialization/base_object.hpp>

namespace quantity {

//
//  the Constant classes
//


template<class BQ, class DQ = DerivedQuantity<typename BQ::QuantityType,
            typename BQ::DU, typename BQ::DDQ> > class Constant;


template<typename QT, typename ST, typename SU, typename DQT>
  class Constant<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > : public Quantity<QT, ST>
    {
      public:

        typedef typename QuantityTraits<QT>::Dimension DIM;


      typedef typename QuantityTraits<QT>::UnitType UT;


      typedef typename QuantityTraits<QT>::UnitList UL;


      typedef typename QuantityTraits<QT>::DefaultUnit DU;


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


        typedef Quantity<QT, ST> BQ; 


        typedef Constant<BQ, DerivedQuantity<QT, SU, DQT> > C;


        typedef Variable<BQ, DerivedQuantity<QT, SU, DQT> > V;

      private:

        ST _value;


//  constructors for Constant

      public:

        Constant (void) : BQ (), _value (ST(0)) 
          {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());}


        Constant (const ST value) : BQ (), _value (value)
          {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());}


        Constant (const ST &value, const std::string &namestring, const std::string &symbolstring)
            : BQ (), _value (value)
          {BQ::name (namestring); BQ::symbol (symbolstring);}


        template<typename NU>
          Constant (const ST &value, const NU &)
            : BQ (), _value (Reverse<SU, ST>::VAL (Standardize<NU, ST>::VAL (value)))
            {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());}


        template<typename NU>
          Constant (const ST &value, const NU &,
                    const std::string &namestring, const std::string &symbolstring)
            : BQ (), _value (Reverse<SU, ST>::VAL (Standardize<NU, ST>::VAL (value)))
            {BQ::name (namestring); BQ::symbol (symbolstring);}


        Constant (const ST value, const std::string &symbol) 
          : BQ ()
            {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());
             ::unit::Unit<UT> *unitp = BQ::findBySymbol (symbol);

             _value = Reverse<StorageUnit, ST>::VAL 
                         (dynamic_standardize<UL>::VAL (value, *unitp));

             delete (unitp);
            }


        Constant (const ST new_value, const char *symbol) 
          : BQ ()
            {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());

             ::unit::Unit<UT> *unitp = BQ::findBySymbol (std::string (symbol));

             _value = Reverse<StorageUnit, ST>::VAL 
                     (dynamic_standardize<UL>::VAL (new_value, *unitp));

             delete (unitp);
            }

//  end constructors for Constant

//  copy constructors for Constant


        template<template<typename, typename> class SM, typename SST>
          Constant (const SM<Quantity<QT, SST>, DQT> &quantity)
            : BQ (), _value (quantity.value ())
              {name (quantity.BQ::name ()); symbol (quantity.BQ::symbol ());}


        template<template<typename, typename> class SM,
                                           typename SST, typename SSU, typename SDQT>
          Constant (const SM<Quantity<QT, SST>, DerivedQuantity<QT, SSU, SDQT> > &quantity)
            : BQ (), _value (Reverse<StorageUnit, ST>::VAL
              (Standardize<SSU, SST>::VAL (quantity.value ())))
              {name (quantity.Quantity<QT, SST>::name ()); 
                  symbol (quantity.Quantity<QT, SST>::symbol ());}



        template<template<typename, typename> class SM,
                             typename SDIM, typename SST, typename SSU, typename SDQT>
          Constant (const SM<Quantity<GenericClass<SDIM>, SST>, 
                             DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > &quantity)
            : BQ (), _value (Reverse<StorageUnit, ST>::VAL
              (Standardize<typename
                 CheckSecondDimension<C,
                   SM<Quantity<GenericClass<SDIM>, SST>, 
                     DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > >
                                  ::RET::StorageUnit, SST>::VAL (quantity.value ())))
              {name (quantity.Quantity<GenericClass<SDIM>, SST>::name ()); 
                symbol (quantity.Quantity<GenericClass<SDIM>, SST>::symbol ());}


        template<template<typename, typename> class SM,
                             typename SQT, typename SST, typename SSU, typename SDQT>
          Constant (const SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > &quantity)
            : BQ (), _value (Reverse<StorageUnit, ST>::VAL
              (Standardize<typename
                 CheckSecondDimension<typename BSUtilities::IF<BSUtilities::SameType<QT,
                   GenericClass<DIM> >::sameType, C, VariableError<true> >::RET,
                     SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
                       ::RET::StorageUnit, SST>::VAL (quantity.value ())))
              {name (quantity.Quantity<SQT, SST>::name ()); 
                 symbol (quantity.Quantity<SQT, SST>::symbol ());}


        Constant (const Dynamic<ST> &dynamic)
          {if (dynamic.isCommensurable (*this))
             _value = Reverse<StorageUnit, ST>::VAL (dynamic.value ());
           else
             {throw DimensionMismatch ();}

          }

//  end copy constructors for Constant

//  assignment operators for Constant

      private:


        template<template<typename, typename> class Q1, typename QT1,
                          typename ST1, typename SDQT>
          Constant & operator= (const Q1<Quantity<QT1, ST1>, SDQT> &);


        template<typename TQ> Constant & operator= (const TQ&);

//  end assignment operators for Constant

//  state reporting member functions for Constant

      public:

        ST value (void) const {return _value;}


        ST standard_value (void) const 
                     {return Standardize<StorageUnit, ST>::VAL (_value);}


          template<typename NU>
            Variable<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> > value (const NU &) const
             {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> >
                (Reverse<typename CheckAgainstAllUnits<NU, UL>::RET, ST>::VAL
                           (Standardize<StorageUnit, ST>::VAL (_value)));}

//    The stored value is first standardized using the
//    Standardize () function for the storage unit, and then dynamically
//    recalculated into the unit found with findBySymbol. The allocated 
//    object pointed to by unitp is deleted. If symbol is not found by
//    findBySymbol, a UnitMismatch exception is thrown.
//*/
//        ST value (const std::string &symbol)
//          {
//            ST value;
//            ::unit::Unit<UT> *unitp = BQ::findBySymbol (symbol);
//
//            value = dynamic_reverse<UL>::VAL
//                    (Standardize<StorageUnit, ST>::VAL (_value), *unitp);
//
//            delete (unitp);
//
//            return value;
//          }


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


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


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


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

//  end state reporting member functions for Constant

//  arithmetic operators for Constant


        typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
                                                     operator+ (void) const
           {typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
                                                        new_constant (*this);
             return new_constant;
           }


        typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
                                                    operator- (void) const
           {typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult 
                                                          new_constant (*this);
             return new_constant *= -ST(1.0);
           }


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


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


        V operator* (const ST factor) const
          {V new_object = *this;
            return new_object *= factor;
          }


          friend V operator*
            (const ST factor, const C &variable)
                         {return V (variable) *= factor;}



        V operator/ (const ST factor) const
          {V new_object = *this;
            return new_object /= factor;
          }


        template<class Q>
          typename GenerateVariable<Constant, Q>::Add operator*
                                                       (const Q &factor)
            {
              return typename GenerateVariable<Constant, Q>::Add
                         (standard_value () * factor.standard_value ());
            }


        template<class Q>
          typename GenerateVariable<Constant, Q>::Sub operator/
                                                       (const Q &factor)
            {
              return typename GenerateVariable<Constant, Q>::Sub
                         (standard_value () / factor.standard_value ());
            }


        friend
          typename GenerateVariable<Constant, Loki::NullType>::Inv 
                  operator/ (const ST numerator, const Constant &factor)
          {
            return typename 
              GenerateVariable<Constant, Loki::NullType>::Inv
                                 (numerator / factor.standard_value ());
          }

//  end arithmetic operators for Constant

//  comparison operators for Constant
//  macro defined in Variable.h

QUANTITY_COMPARISON_OPERATORS(Constant, operator==, ==)
QUANTITY_COMPARISON_OPERATORS(Constant, operator!=, !=)
QUANTITY_COMPARISON_OPERATORS(Constant, operator>, >)
QUANTITY_COMPARISON_OPERATORS(Constant, operator<, <)
QUANTITY_COMPARISON_OPERATORS(Constant, operator>=, >=)
QUANTITY_COMPARISON_OPERATORS(Constant, operator<=, <=)

//  end comparison operators for Constant


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


        template<int I>
          typename GenerateVariable<Constant,
              BSUtilities::Rational<I, long(1)> >::Mult
                           pow (const typename Loki::Int2Type<I>) const
          {return std::pow (standard_value (), I);}


    template<class T>
      Dynamic<ST> pow (const T &exp) const
                                {return Dynamic<ST>::pow (*this, exp);}


        typename
          GenerateVariable<Constant, BSUtilities::Rational<1, 2>
                                               >::Mult sqrt (void) const
          {
            return typename
              GenerateVariable<Constant, BSUtilities::Rational<1, 2>
                                 >::Mult (std::sqrt(standard_value ()));
          }



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


      void operator>> (std::string &str) const
          {str = BSUtilities::Conversion<Constant>::to_string (*this);}


      std::ostream & operator>> (std::ostream &os) const
                   {return this->print (os);}

  private:
      friend class boost::serialization::access;


      template<typename Archive>
        void serialize (Archive &ar, const unsigned int )
        {
          ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(BQ);
          ar & BOOST_SERIALIZATION_NVP(_value);
        }

    };

}

#endif /* _Constant_h */

---