C:/nobackup/private/physical_svn/trunk/include/physical/detail/dynamicphysical_impl.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_IMPL
#define PHYSICAL_DYNAMICPHYSICAL_IMPL

#include "physical/dynamicphysical.hpp"
#include "physical/dynamicunit.hpp"

namespace physical {

   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>& DynamicPhysical<UnitSystem>::operator*=(DynamicPhysical<UnitSystem> b){
                *this = *this * b;
                return *this;
        };


        // arithmetic operators

   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>
        operator+(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents) 
                        throw IncompatibleUnitException("cannot add quantities with different dimensions");
                return DynamicPhysical<UnitSystem>(a.numerical_value+b.numerical_value, a.exponents);
        };

   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>
        operator-(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents) 
                        throw IncompatibleUnitException("cannot substract quantities with different dimensions");
                return DynamicPhysical<UnitSystem>(a.numerical_value-b.numerical_value, a.exponents);
        };


   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>
        operator*(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                return DynamicPhysical<UnitSystem>(a.numerical_value*b.numerical_value, a.exponents+b.exponents);
        };

   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>
        operator*(double a, DynamicPhysical<UnitSystem> b) {
                return DynamicPhysical<UnitSystem>(a*b.numerical_value, b.exponents);
        };


   template<class UnitSystem> 
        DynamicPhysical<UnitSystem>
        operator/(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                return DynamicPhysical<UnitSystem>(a.numerical_value / b.numerical_value, a.exponents-b.exponents);
        };

        // comparision operators

   template<class UnitSystem> 
        bool operator==(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a==b;
        };

   template<class UnitSystem> 
        bool operator!=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a!=b;
        };

   template<class UnitSystem> 
        bool operator>=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a>=b;
        };

   template<class UnitSystem> 
        bool operator<=(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a<=b;
        };

   template<class UnitSystem> 
        bool operator>(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a>b;
        };

   template<class UnitSystem> 
        bool operator<(DynamicPhysical<UnitSystem> a, DynamicPhysical<UnitSystem> b) {
                if (a.exponents != b.exponents){
                        throw IncompatibleUnitException("cannot compare quantities with different dimensions");
                };
                return a<b;
        };

        // other functions

   template<class UnitSystem> 
        DynamicPhysical<UnitSystem> power(DynamicPhysical<UnitSystem> a, int n) {
                DynamicPhysical r=1.;
                while(n>0) {r=r*a; --n;};
                while(n<0) {r=r/a; ++n;};
                return r;
        };



        // this multiplication serves as a conversion from unit to quantity
   template<class UnitSystem> 
        DynamicPhysical<UnitSystem> operator*(double real, const DynamicUnit<UnitSystem>& unit)
        {
                return DynamicPhysical<UnitSystem>(real*unit.scale.factor + unit.scale.origin, unit.exponents);
        };

        // division by unit works a bit different from division by quantity:
   template<class UnitSystem> 
        DynamicPhysical<UnitSystem> operator/(DynamicPhysical<UnitSystem> quantity, const DynamicUnit<UnitSystem> unit)
        {
                return DynamicPhysical<UnitSystem>((quantity.numerical_value - unit.scale.origin)/ unit.scale.factor, unit.exponents);
        };

}; // namespace physical


#endif // PHYSICAL_DYNAMICPHYSICAL_IMPL

---

hosted on