C:/nobackup/private/physical_svn/trunk/include/physical/fixedphysical.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_FIXEDPHYSICAL
#define PHYSICAL_FIXEDPHYSICAL

#include "physical/detail/fixedexponents.hpp"
#include "physical/detail/larger_type.hpp"


namespace physical {

   template<class UnitSystem>
        struct DynamicPhysical; // forward declaration

        template<class UnitSystem, typename T, class Exponents>
        struct FixedPhysical{
      typedef UnitSystem unitsystem;
                typedef Exponents exponents;
                typedef T numerical_value_t;
                numerical_value_t numerical_value;

                explicit FixedPhysical(numerical_value_t v):numerical_value(v){};

                FixedPhysical(const FixedPhysical& v): numerical_value(v.numerical_value){};

                FixedPhysical(const DynamicPhysical<UnitSystem>& v); 

                template<typename T2>
                FixedPhysical(const FixedPhysical<UnitSystem, T2, exponents>& v): numerical_value(v.numerical_value){};

      // automatically created assignment & d'tor are okay.
   };



   template <class Q1, class Q2> struct FixedPhysicalSum; // no general implementation provided, only some specialisations

        template<class UnitSystem, typename T1, typename T2, class Exponents1, class Exponents2>
        struct FixedPhysicalSum< FixedPhysical<UnitSystem, T1, Exponents1>, FixedPhysical<UnitSystem, T2, Exponents2> >{
                BOOST_STATIC_ASSERT((boost::is_same<typename Exponents1::dimensions, typename Exponents2::dimensions>::type::value ));
                typedef typename detail::larger_type<T1, T2>::type numerical_value_t;
                typedef FixedPhysical< UnitSystem, numerical_value_t, Exponents1 > type;
        }; 

        // FixedPhysicalDifference would be excatly the same type as FixedPhysicalSum..



   template <class Q1, class Q2> struct FixedPhysicalRatio; // no general implementation provided, only some specialisations

        template<class UnitSystem, typename T1, typename T2, class Exponents1, class Exponents2>
        struct FixedPhysicalRatio< FixedPhysical<UnitSystem, T1, Exponents1>, FixedPhysical<UnitSystem, T2, Exponents2> >{
                typedef typename detail::larger_type<T1, T2>::type numerical_value_t;
      typedef FixedPhysical< UnitSystem, numerical_value_t, typename detail::minus<Exponents1, typename Exponents2>::type > type;
        }; 



   template <class Q1, class Q2> struct FixedPhysicalProduct; // no general implementation provided, only some specialisations

        template<class UnitSystem, typename T1, typename T2, class Exponents1, class Exponents2>
        struct FixedPhysicalProduct< FixedPhysical<UnitSystem, T1, Exponents1>, FixedPhysical<UnitSystem, T2, Exponents2> >{
                typedef typename detail::larger_type<T1, T2>::type numerical_value_t;
                typedef FixedPhysical< UnitSystem, numerical_value_t, typename detail::plus<Exponents1, Exponents2>::type > type;
        }; 



        // arithmetic operators

        template<class UnitSystem, typename T1, typename T2, class exponents>
        typename FixedPhysicalSum< FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type
        operator+(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                typedef FixedPhysicalSum<FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type return_type;
                return  retrun_type(a.numerical_value + b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        typename FixedPhysicalSum< FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type
        operator-(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                typedef FixedPhysicalSum<FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type return_type;
                return  retrun_type(a.numerical_value - b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
        typename FixedPhysicalProduct< FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type
        operator*(const FixedPhysical<UnitSystem, T1, exponents1> a, FixedPhysical<UnitSystem, T2, exponents2> b){
                typedef FixedPhysicalProduct<FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type return_type;
                return return_type(a.numerical_value * b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
        typename FixedPhysicalRatio< FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type
        operator/(const FixedPhysical<UnitSystem, T1, exponents1> a, FixedPhysical<UnitSystem, T2, exponents2> b){
                typedef FixedPhysicalRatio<FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type return_type;
                return return_type(a.numerical_value / b.numerical_value);
        };

        // comparision operators

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator==(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value == b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator!=(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value != b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator>=(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value >= b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator<=(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value <= b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator>(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value > b.numerical_value);
        };

        template<class UnitSystem, typename T1, typename T2, class exponents>
        bool
        operator<(const FixedPhysical<UnitSystem, T1, exponents> a, FixedPhysical<UnitSystem, T2, exponents> b){
                return  retrun_type(a.numerical_value < b.numerical_value);
        };

        // FixedPhysical with "unit-vector" exponents
        template <class UnitSystem, typename T, int P>
        struct FixedPhysicalBase{
                typedef FixedPhysical< UnitSystem, T, typename detail::FixExponents<UnitSystem, P>::type > type;
        }; 

        // specialisation: FixedPhysical with "zero-vector" exponents
        template <class UnitSystem, typename T>
        struct FixedPhysicalBase<UnitSystem, T, -1>{
                typedef FixedPhysical< UnitSystem, T,
                        detail::FixedExponents<UnitSystem, typename detail::zero_vector<UnitSystem::number_baseunits>::type>
                > type;
        }; 


        // scalar multiplication 
        template<class UnitSystem, typename T1, typename T2, class exponents1>
        FixedPhysical<UnitSystem, typename detail::larger_type<T1, T2>::type, exponents1>
        operator*(const T1 a, const FixedPhysical<UnitSystem, T2, exponents1> b){
                typedef FixedPhysical<UnitSystem, typename detail::larger_type<T1, T2>::type, exponents1> return_type;
                return return_type(a * b.numerical_value);
        };

}; // namespace physical

#endif

---

hosted on