Quantities: Constant.h Source File

00001 
00005 /* Copyright (C) 2002 - 2010, Bernd Speiser */
00006 /* This file is part of Quantity.
00007 
00008 Quantity is free software; you can redistribute it and/or
00009 modify it under the terms of the GNU General Public License
00010 as published by the Free Software Foundation; either version 2
00011 of the License, or (at your option) any later version.
00012 
00013 Quantity is distributed in the hope that it will be useful,
00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 GNU General Public License for more details.
00017   
00018 You should have received a copy of the GNU General Public License
00019 along with this program; if not, write to the Free Software
00020 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00021 02111-1307, USA.
00022 */
00023 
00024 #ifndef _Constant_h
00025 #define _Constant_h
00026 
00027 // Quantity includes
00028 #include "Quantities/Quantity/Quantity.h"
00029 #include "Quantities/Quantity/QuantityError.h"
00030 #include "Quantities/Quantity/Variable.h"
00031 
00032 // BOOST includes
00033 #include <boost/serialization/base_object.hpp>
00034 
00035 namespace quantity {
00036 
00038 //
00039 //  the Constant classes
00040 //
00042 
00044 
00050 template<class BQ, class DQ = DerivedQuantity<typename BQ::QT,
00051             typename BQ::DU, typename BQ::DDQ> > class Constant;
00052 
00054 
00064 template<typename QT, typename ST, typename DQSU, typename DQT>
00065   class Constant<Quantity<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > 
00066                                                       : public Quantity<QT, ST>
00067     {
00068       public:
00070 
00072         typedef typename QuantityTraits<QT>::Dimension DIM;
00073 
00075 
00077       typedef typename QuantityTraits<QT>::UnitType UT;
00078 
00080 
00082       typedef typename QuantityTraits<QT>::UnitList UL;
00083 
00085 
00088         typedef Quantity<QT, ST> BQ; 
00089 
00091 
00094       typedef typename BQ::DU DU;
00095 
00097 
00099       typedef typename unit::ValidUnit<DQSU, UL>::RET SU;
00100 
00102 
00104         typedef Constant<BQ, DerivedQuantity<QT, SU, DQT> > C;
00105 
00107 
00110         typedef Variable<BQ, DerivedQuantity<QT, SU, DQT> > V;
00111 
00112       private:
00114 
00118         ST _value;
00119 
00120 
00122 //  constructors for Constant
00124 
00125       public:
00127 
00133         Constant (void) : BQ (), _value (ST(0)) 
00134           {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());}
00135 
00137 
00143         Constant (const ST value) : BQ (), _value (value)
00144           {name (Name<QT, DQT>::exec ()); symbol (Symbol<QT, DQT>::exec ());}
00145 
00147 
00155         Constant (const ST &value, const std::string &namestring, const std::string &symbolstring)
00156             : BQ (), _value (value)
00157           {BQ::name (namestring); BQ::symbol (symbolstring);}
00158 
00160 
00166         template<typename NU>
00167           Constant (const ST &value, const NU &)
00168             : BQ (), _value (unit::Reverse<SU>::VAL (unit::Standard<NU>::VAL (value)))
00169             {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());}
00170 
00172 
00180         template<typename NU>
00181           Constant (const ST &value, const NU &,
00182                     const std::string &namestring, const std::string &symbolstring)
00183             : BQ (), _value (unit::Reverse<SU>::VAL (unit::Standard<NU>::VAL (value)))
00184             {BQ::name (namestring); BQ::symbol (symbolstring);}
00185 
00187 
00194         Constant (const ST value, const std::string &symbol) 
00195           : BQ ()
00196             {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());
00197             _value = unit::Reverse<SU>::VAL
00198                (unit::standard<UL>::VAL (value, symbol));
00199 
00200             }
00201 
00203 
00210         Constant (const ST new_value, const char *symbol) 
00211           : BQ ()
00212             {name (Name<QT, DQT>::exec ()); symbol(Symbol<QT, DQT>::exec ());
00213             _value = unit::Reverse<SU>::VAL
00214                (unit::standard<UL>::VAL (value, symbol));
00215 
00216 
00217             }
00218 
00220 //  end constructors for Constant
00222 
00224 //  copy constructors for Constant
00226 
00228 
00233         template<template<typename, typename> class SM, typename SST>
00234           Constant (const SM<Quantity<QT, SST>, DQT> &quantity)
00235             : BQ (), _value (quantity.value ())
00236               {name (quantity.BQ::name ()); symbol (quantity.BQ::symbol ());}
00237 
00239 
00250         template<template<typename, typename> class SM,
00251                                            typename SST, typename SSU, typename SDQT>
00252           Constant (const SM<Quantity<QT, SST>, DerivedQuantity<QT, SSU, SDQT> > &quantity)
00253             : BQ (), _value (unit::Reverse<SU>::VAL
00254               (unit::Standard<SSU>::VAL (quantity.value ())))
00255               {name (quantity.Quantity<QT, SST>::name ()); 
00256                   symbol (quantity.Quantity<QT, SST>::symbol ());}
00257 
00258 
00260 
00267         template<template<typename, typename> class SM,
00268                              typename SDIM, typename SST, typename SSU, typename SDQT>
00269           Constant (const SM<Quantity<GenericClass<SDIM>, SST>, 
00270                              DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > &quantity)
00271             : BQ (), _value (unit::Reverse<SU>::VAL
00272               (unit::Standard<typename
00273                  CheckSecondDimension<C,
00274                    SM<Quantity<GenericClass<SDIM>, SST>, 
00275                      DerivedQuantity<GenericClass<SDIM>, SSU, SDQT> > >
00276                                   ::RET::SU>::VAL (quantity.value ())))
00277               {name (quantity.Quantity<GenericClass<SDIM>, SST>::name ()); 
00278                 symbol (quantity.Quantity<GenericClass<SDIM>, SST>::symbol ());}
00279 
00281 
00292         template<template<typename, typename> class SM,
00293                              typename SQT, typename SST, typename SSU, typename SDQT>
00294           Constant (const SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > &quantity)
00295             : BQ (), _value (unit::Reverse<SU>::VAL
00296               (unit::Standard<typename
00297                  CheckSecondDimension<typename BSUtilities::IF<BSUtilities::SameType<QT,
00298                    GenericClass<DIM> >::sameType, C, VariableError<true> >::RET,
00299                      SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
00300                        ::RET::SU>::VAL (quantity.value ())))
00301               {name (quantity.Quantity<SQT, SST>::name ()); 
00302                  symbol (quantity.Quantity<SQT, SST>::symbol ());}
00303 
00305 
00310         Constant (const Dynamic<ST> &dynamic)
00311           {if (dynamic.isCommensurable (*this))
00312              _value = unit::Reverse<SU>::VAL (dynamic.value ());
00313            else
00314              {throw DimensionMismatch ();}
00315 
00316           }
00317 
00319 //  end copy constructors for Constant
00321 
00323 //  assignment operators for Constant
00325 
00326       private:
00327 
00329 
00332         template<template<typename, typename> class Q1, typename QT1,
00333                           typename ST1, typename SDQT>
00334           Constant & operator= (const Q1<Quantity<QT1, ST1>, SDQT> &);
00335 
00337 
00340         template<typename TQ> Constant & operator= (const TQ&);
00341 
00343 //  end assignment operators for Constant
00345 
00347 //  state reporting member functions for Constant
00349 
00350       public:
00352 
00354         ST value (void) const {return _value;}
00355 
00357 
00360         ST standard_value (void) const 
00361                      {return unit::Standard<SU>::VAL (_value);}
00362 
00364 
00370           template<typename NU>
00371             Variable<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> > value (const NU &) const
00372              {return Variable<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> >
00373                 (unit::Reverse<typename unit::ValidUnit<NU, UL>::RET>::VAL
00374                            (unit::Standard<SU>::VAL (_value)));}
00375 
00377 
00384         ST value (const std::string &unitsymbol)
00385           {
00386             ST value;
00387             value = unit::reverse<UL>::VAL
00388                     (unit::Standard<SU>::VAL (_value), unitsymbol);
00389             return value;
00390           }
00391 
00393 
00395         ST value (const char * unitsymbol)
00396           {return value (std::string (unitsymbol));}
00397 
00399 
00401         std::string unitsymbol (void) const {return SU::Symbol ();}
00402 
00404 
00406         static std::string Unitsymbol (void) {return SU::Symbol ();}
00407 
00409 
00411         std::string unitname (void) const {return SU::Name ();}
00412 
00414 
00416         static std::string Unitname (void) {return SU::Name ();}
00417 
00419 //  end state reporting member functions for Constant
00421 
00423 //  arithmetic operators for Constant
00425 
00427 
00430         typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
00431                                                      operator+ (void) const
00432            {typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
00433                                                         new_constant (*this);
00434              return new_constant;
00435            }
00436 
00438 
00441         typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult
00442                                                     operator- (void) const
00443            {typename GenerateVariable<C, BSUtilities::Rational<1> >::Mult 
00444                                                           new_constant (*this);
00445              return new_constant *= -ST(1.0);
00446            }
00447 
00449 
00452         template <class Q>
00453           V operator+ (const Q &new_variable) const
00454             {V new_object = *this;
00455               return (new_object + new_variable);
00456             }
00457 
00459 
00462         template <class Q>
00463           V operator- (const Q &new_variable) const
00464             {V new_object = *this;
00465               return new_object -= new_variable;
00466             }
00467 
00469 
00471         V operator* (const ST factor) const
00472           {V new_object = *this;
00473             return new_object *= factor;
00474           }
00475 
00476 
00478           friend V operator*
00479             (const ST factor, const C &variable)
00480                          {return V (variable) *= factor;}
00481 
00482 
00484 
00486         V operator/ (const ST factor) const
00487           {V new_object = *this;
00488             return new_object /= factor;
00489           }
00490 
00492 
00497         template<class Q>
00498           typename GenerateVariable<Constant, Q>::Add operator*
00499                                                        (const Q &factor)
00500             {
00501               return typename GenerateVariable<Constant, Q>::Add
00502                          (standard_value () * factor.standard_value ());
00503             }
00504 
00506 
00511         template<class Q>
00512           typename GenerateVariable<Constant, Q>::Sub operator/
00513                                                        (const Q &factor)
00514             {
00515               return typename GenerateVariable<Constant, Q>::Sub
00516                          (standard_value () / factor.standard_value ());
00517             }
00518 
00520 
00523         friend
00524           typename GenerateVariable<Constant, Loki::NullType>::Inv 
00525                   operator/ (const ST numerator, const Constant &factor)
00526           {
00527             return typename 
00528               GenerateVariable<Constant, Loki::NullType>::Inv
00529                                  (numerator / factor.standard_value ());
00530           }
00531 
00533 //  end arithmetic operators for Constant
00535 
00537 //  comparison operators for Constant
00538 //  macro defined in Variable.h
00540 
00541 QUANTITY_COMPARISON_OPERATORS(Constant, operator==, ==)
00542 QUANTITY_COMPARISON_OPERATORS(Constant, operator!=, !=)
00543 QUANTITY_COMPARISON_OPERATORS(Constant, operator>, >)
00544 QUANTITY_COMPARISON_OPERATORS(Constant, operator<, <)
00545 QUANTITY_COMPARISON_OPERATORS(Constant, operator>=, >=)
00546 QUANTITY_COMPARISON_OPERATORS(Constant, operator<=, <=)
00547 
00549 //  end comparison operators for Constant
00551 
00553 
00560         template<long N, long D>
00561           typename GenerateVariable<Constant,
00562                                      BSUtilities::Rational<N, D> >::Mult
00563                          pow (const BSUtilities::Rational<N, D> &) const
00564           {return std::pow (standard_value (), 
00565                         static_cast<double>(N)/static_cast<double>(D));}
00566 
00568 
00575         template<int I>
00576           typename GenerateVariable<Constant,
00577               BSUtilities::Rational<I, long(1)> >::Mult
00578                            pow (const typename Loki::Int2Type<I>) const
00579           {return std::pow (standard_value (), I);}
00580 
00582 
00588     template<class T>
00589       Dynamic<ST> pow (const T &exp) const
00590                                 {return Dynamic<ST>::pow (*this, exp);}
00591 
00593 
00600         typename
00601           GenerateVariable<Constant, BSUtilities::Rational<1, 2>
00602                                                >::Mult sqrt (void) const
00603           {
00604             return typename
00605               GenerateVariable<Constant, BSUtilities::Rational<1, 2>
00606                                  >::Mult (std::sqrt(standard_value ()));
00607           }
00608 
00609 
00611 
00614       std::ostream & print_value (std::ostream &os) const
00615         {return os << _value << " " << SU::Symbol ();}
00616 
00618 
00620       void operator>> (std::string &str) const
00621           {str = BSUtilities::Conversion<Constant>::to_string (*this);}
00622 
00624 
00628       std::ostream & operator>> (std::ostream &os) const
00629                    {return this->print (os);}
00630 
00631   private:
00633       friend class boost::serialization::access;
00634 
00636 
00638       template<typename Archive>
00639         void serialize (Archive &ar, const unsigned int )
00640         {
00641           ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(BQ);
00642           ar & BOOST_SERIALIZATION_NVP(_value);
00643         }
00644 
00645     };
00646 
00647 }
00648 
00649 #endif /* _Constant_h */