C:/nobackup/private/physical_svn/trunk/include/physical/Copy of 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 {

        struct DynamicPhysical; // forward declaration

        template<typename T, class Exponents>
        struct FixedPhysical{
                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& v); 

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

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


        template <class Q1, class Q2>
        struct FixedPhysicalSum{
                typedef typename Q1::exponents E1;
                typedef typename Q2::exponents E2;
                BOOST_STATIC_ASSERT((boost::is_same<typename E1::dimensions, typename E2::dimensions>::type::value ));
                typedef typename detail::larger_type<typename Q1::numerical_value_t, typename Q2::numerical_value_t>::type numerical_value_t;
                typedef FixedPhysical< numerical_value_t, typename Q1::exponents > type;
        }; 

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

        template <class E1, class E2>
        struct FixedPhysicalRatio{
                typedef typename detail::larger_type<typename E1::numerical_value_t, typename E2::numerical_value_t>::type numerical_value_t;
                typedef FixedPhysical< numerical_value_t, typename detail::minus<typename E1::exponents, typename E2::exponents>::type > type;
        }; 

        template <class Q1, class Q2>
        struct FixedPhysicalProduct{
                typedef typename detail::larger_type<typename Q1::numerical_value_t, typename Q2::numerical_value_t>::type numerical_value_t;
                typedef FixedPhysical< numerical_value_t, typename detail::plus<typename Q1::exponents, typename Q2::exponents>::type > type;
        }; 

        // arithmetic operators

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

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

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

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

        // comparision operators

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

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

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

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

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

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

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

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


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

}; // namespace physical

#endif

---

hosted on