UniqueConstant.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 _UniqueConstant_h
#define _UniqueConstant_h

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

// Loki includes
#include "loki/Singleton.h"

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

namespace quantity {

//
//  the UniqueConstant classes
//


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


template<typename QT, typename ST, typename SU, typename DQT>
  class UniqueConstant<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 UniqueConstant<BQ, DerivedQuantity<QT, SU, DQT> > UC;


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


        friend class Loki::CreateUsingNew<UC>;

      private:

        static const ST default_value_;


        ST _value;

//  constructors for UniqueConstant

      private:

        UniqueConstant (void) : BQ (), _value (default_value_) 
          {BQ::name (Name<QT, DQT>::exec ()); BQ::symbol (Symbol<QT, DQT>::exec ());}

      private:

        UniqueConstant (const UniqueConstant &)
          : BQ (), _value (default_value_) {}

//  end constructors for UniqueConstant

//  destructor for UniqueConstant


      private:
        ~UniqueConstant (void) {}

//  end destructor for UniqueConstant

//  other private special member functions for UniqueConstant


      private:
        UniqueConstant & operator= (const UniqueConstant &);


      private:
        void operator& ();

//  end other private special member functions for UniqueConstant

//  state reporting member functions for UniqueConstant

      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 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;
//          }

    protected:

      void name (const std::string &namestring) {BQ::name (namestring);}


      void symbol (const std::string &symbolstring) {BQ::symbol (symbolstring);}

    public:

        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 ();}


        std::string name (void) const {return BQ::name ();}


        std::string symbol (void) const {return BQ::symbol ();}

//  end state reporting member functions for UniqueConstant

//  arithmetic operators for UniqueConstant


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


        typename GenerateVariable<UC, BSUtilities::Rational<1> >::Mult operator- (void) const
           {typename GenerateVariable<UC, 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;
          }

// maybe no longer necessary, see Variable
        friend V operator*
            (const ST factor, const UC &variable)
                         {return V (variable) *= factor;}



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


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


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


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

//  end arithmetic operators for UniqueConstant

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

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

//  end comparison operators for UniqueConstant


        template<long N, long D> 
          typename GenerateVariable<UniqueConstant,
                                     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<UniqueConstant,
              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<UniqueConstant, BSUtilities::Rational<1, 2>
                                               >::Mult sqrt (void) const
          {
            return typename
              GenerateVariable<UniqueConstant, 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<UniqueConstant>::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);
        }

    };

}

#endif /* _UniqueConstant_h */

---