C:/nobackup/private/physical_svn/trunk/include/physical/dynamicphysical.hpp

Go to the documentation of this file.

/*=============================================================================
    physical quantities / units / constants
    Copyright (c) 2006, 2007 Martin Schulz
    http://physical.sourceforge.net
  
    This is private code by Martin Schulz.
  
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#ifndef PHYSICAL_DYNAMICPHYSICAL
#define PHYSICAL_DYNAMICPHYSICAL

#include "physical/fixedphysical.hpp"
#include "physical/dynamicunit.hpp"
#include "physical/exception.hpp"


namespace physical {

   template<class UnitSystem>
        struct DynamicPhysical {
                detail::DynamicExponents<UnitSystem> exponents;
                double numerical_value;
                
      template<class UnitSystem, typename T, class Exponents>
                DynamicPhysical(FixedPhysical<UnitSystem, T, Exponents> q)
                        : numerical_value(q.numerical_value)
                        , exponents(Exponents())
                {};


                DynamicPhysical(double v=0., detail::DynamicExponents<UnitSystem> exponents = detail::DynamicExponents<UnitSystem>())
                        : numerical_value(v)
                        , exponents(exponents)
                {};

                DynamicPhysical& operator*=(DynamicPhysical b);
        };

        // arithmetic operators

        template<class UnitSystem> DynamicPhysical<UnitSystem> operator+(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator-(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator*(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator*(double a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator/(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);

        // comparision operators

        template<class UnitSystem> bool operator==(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> bool operator!=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> bool operator>=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> bool operator<=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> bool operator>(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);
        template<class UnitSystem> bool operator<(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b);

        // other functions

        template<class UnitSystem> DynamicPhysical<UnitSystem> power(DynamicPhysical<UnitSystem> a, int n);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator*(double real, const DynamicUnit<UnitSystem>& unit);
        template<class UnitSystem> DynamicPhysical<UnitSystem> operator/(DynamicPhysical<UnitSystem> quantity, const DynamicUnit<UnitSystem> unit);


        // templated member definition (of FixedPhysical) moved here to avoid header dependency
        template<class UnitSystem, typename T, class Exponents>
        FixedPhysical<UnitSystem, T, Exponents>::FixedPhysical(const DynamicPhysical<UnitSystem>& v) {

                detail::DynamicExponents<UnitSystem> dynexp( (typename exponents()) );

                if (dynexp==v.exponents) {
                        numerical_value = v.numerical_value;
                } else {
                        // incompatible dimension, throw exception:
                        throw IncompatibleUnitException("attempt of conversion between incompatible quantities");
                };
        }


}; // namspeace physical


// include the implementation deatils
#include "physical/detail/dynamicphysical_impl.hpp"

#endif

---

hosted on