C:/nobackup/private/physical_svn/trunk/include/physical/detail/dynamicexponents.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_DYNAMICEXPONENTS
#define PHYSICAL_DYNAMICEXPONENTS

#include "physical/config.hpp"

#include <algorithm>
#include <functional>
#include <cassert>
#include <vector>

#include <boost/mpl/for_each.hpp>

namespace physical {

        namespace detail {

                template<class UnitSystem>
                struct DynamicExponents {
                        std::vector<int> exponents;
                        
                        DynamicExponents()
                                : exponents(UnitSystem::number_baseunits,0)
                        {};
                        
                        DynamicExponents(const std::vector<int>& v)
                                : exponents(v)
                        {};


                        struct append_to {
                                std::vector<int>&vec;
                                append_to(std::vector<int>&v):vec(v) {};
                                void operator()(int t) { vec.push_back(t); };
                        };

                        // conversion from static to dynamic exponents
                        template<class Exponents>
                        DynamicExponents(Exponents)
                        {
                                boost::mpl::for_each<typename Exponents::dimensions>(append_to(exponents));
                        };
                };

                template<class UnitSystem>
                inline DynamicExponents<UnitSystem> 
                operator+(DynamicExponents<UnitSystem> exponents1, DynamicExponents<UnitSystem> exponents2){
                        std::vector<int> v(exponents1.exponents.size());
                        std::transform(exponents1.exponents.begin(), exponents1.exponents.end(), 
                                           exponents2.exponents.begin(), v.begin(), std::plus<int>());
                        return DynamicExponents<UnitSystem>(v);
                };


                template<class UnitSystem>
                inline DynamicExponents<UnitSystem> 
                operator-(DynamicExponents<UnitSystem> exponents1, DynamicExponents<UnitSystem> exponents2){
                        std::vector<int> v(exponents1.exponents.size());
                        std::transform(exponents1.exponents.begin(), exponents1.exponents.end(), 
                                           exponents2.exponents.begin(), v.begin(), std::minus<int>());
                        return DynamicExponents<UnitSystem>(v);
                };



                template<class UnitSystem>
                inline bool operator==(DynamicExponents<UnitSystem> a, DynamicExponents<UnitSystem> b) {
                        assert(a.exponents.size() == UnitSystem::number_baseunits);
                        assert(b.exponents.size() == UnitSystem::number_baseunits);
         if (a.exponents.size()!=b.exponents.size()) return false;
         return std::equal(a.exponents.begin(), a.exponents.end(), b.exponents.begin());
                };



                template<class UnitSystem>
                inline bool operator!=(DynamicExponents<UnitSystem> a, DynamicExponents<UnitSystem> b) {
         return !operator==(a, b);
                };

        }; // namespace detail

}; // namespace physical


#endif

---

hosted on