| // Boost.Units - A C++ library for zero-overhead dimensional analysis and |
| // unit/quantity manipulation and conversion |
| // |
| // Copyright (C) 2003-2008 Matthias Christian Schabel |
| // Copyright (C) 2007-2008 Steven Watanabe |
| // |
| // Distributed under 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 BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP |
| #define BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP |
| |
| /// \file |
| /// \brief A heterogeneous system is a sorted list of base unit/exponent pairs. |
| |
| #include <boost/mpl/bool.hpp> |
| #include <boost/mpl/plus.hpp> |
| #include <boost/mpl/times.hpp> |
| #include <boost/mpl/divides.hpp> |
| #include <boost/mpl/negate.hpp> |
| #include <boost/mpl/less.hpp> |
| #include <boost/mpl/size.hpp> |
| #include <boost/mpl/begin.hpp> |
| #include <boost/mpl/next.hpp> |
| #include <boost/mpl/deref.hpp> |
| #include <boost/mpl/front.hpp> |
| #include <boost/mpl/push_front.hpp> |
| #include <boost/mpl/pop_front.hpp> |
| #include <boost/mpl/assert.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| |
| #include <boost/units/config.hpp> |
| #include <boost/units/static_rational.hpp> |
| #include <boost/units/dimension.hpp> |
| #include <boost/units/units_fwd.hpp> |
| #include <boost/units/detail/push_front_if.hpp> |
| #include <boost/units/detail/push_front_or_add.hpp> |
| #include <boost/units/detail/linear_algebra.hpp> |
| #include <boost/units/detail/unscale.hpp> |
| |
| namespace boost { |
| |
| namespace units { |
| |
| namespace detail { |
| |
| // A normal system is a sorted list of base units. |
| // A heterogeneous system is a sorted list of base unit/exponent pairs. |
| // As long as we don't need to convert heterogeneous systems |
| // directly everything is cool. |
| |
| template<class T> |
| struct is_zero : mpl::false_ {}; |
| |
| template<> |
| struct is_zero<static_rational<0> > : mpl::true_ {}; |
| |
| } // namespace detail |
| |
| /// INTERNAL ONLY |
| template<class L, class Dimensions, class Scale> |
| struct heterogeneous_system_impl |
| { |
| typedef L type; |
| typedef Dimensions dimensions; |
| typedef Scale scale; |
| }; |
| |
| /// INTERNAL ONLY |
| typedef dimensionless_type no_scale; |
| |
| /// A system that can represent any possible combination |
| /// of units at the expense of not preserving information |
| /// about how it was created. Do not create specializations |
| /// of this template directly. Instead use @c reduce_unit and |
| /// @c base_unit<...>::unit_type. |
| template<class T> |
| struct heterogeneous_system : T {}; |
| |
| /// INTERNAL ONLY |
| struct heterogeneous_system_dim_tag {}; |
| |
| /// INTERNAL ONLY |
| template<class Unit, class Exponent> |
| struct heterogeneous_system_dim |
| { |
| typedef heterogeneous_system_dim_tag tag; |
| typedef heterogeneous_system_dim type; |
| typedef Unit tag_type; |
| typedef Exponent value_type; |
| }; |
| |
| /// INTERNAL ONLY |
| #define BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(BaseUnit, Dimensions) \ |
| boost::units::unit< \ |
| Dimensions, \ |
| boost::units::heterogeneous_system< \ |
| boost::units::heterogeneous_system_impl< \ |
| boost::units::list< \ |
| boost::units::heterogeneous_system_dim< \ |
| BaseUnit, \ |
| boost::units::static_rational<1> \ |
| >, \ |
| boost::units::dimensionless_type \ |
| >, \ |
| Dimensions, \ |
| boost::units::no_scale \ |
| > \ |
| > \ |
| > |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| |
| #if BOOST_UNITS_HAS_BOOST_TYPEOF |
| |
| #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() |
| |
| BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_impl, (class)(class)(class)) |
| BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system, (class)) |
| BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_dim, (class)(class)) |
| |
| #endif |
| |
| namespace boost { |
| |
| namespace mpl { |
| |
| /// INTERNAL ONLY |
| template<> |
| struct less_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag> |
| { |
| template<class T0, class T1> |
| struct apply : mpl::less<typename T0::tag_type, typename T1::tag_type> {}; |
| }; |
| |
| } |
| |
| namespace units { |
| |
| namespace detail { |
| |
| template<class Unit1, class Exponent1> |
| struct is_empty_dim<heterogeneous_system_dim<Unit1,Exponent1> > : detail::is_zero<Exponent1> {}; |
| |
| } // namespace detail |
| |
| } // namespace units |
| |
| namespace mpl { |
| |
| /// INTERNAL ONLY |
| template<> |
| struct plus_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag> |
| { |
| template<class T0, class T1> |
| struct apply |
| { |
| typedef boost::units::heterogeneous_system_dim< |
| typename T0::tag_type, |
| typename mpl::plus<typename T0::value_type,typename T1::value_type>::type |
| > type; |
| }; |
| }; |
| |
| /// INTERNAL ONLY |
| template<> |
| struct times_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag> |
| { |
| template<class T0, class T1> |
| struct apply |
| { |
| typedef boost::units::heterogeneous_system_dim< |
| typename T0::tag_type, |
| typename mpl::times<typename T0::value_type,T1>::type |
| > type; |
| }; |
| }; |
| |
| /// INTERNAL ONLY |
| template<> |
| struct divides_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag> |
| { |
| template<class T0, class T1> |
| struct apply |
| { |
| typedef boost::units::heterogeneous_system_dim< |
| typename T0::tag_type, |
| typename mpl::divides<typename T0::value_type,T1>::type |
| > type; |
| }; |
| }; |
| |
| /// INTERNAL ONLY |
| template<> |
| struct negate_impl<boost::units::heterogeneous_system_dim_tag> |
| { |
| template<class T> |
| struct apply |
| { |
| typedef boost::units::heterogeneous_system_dim<typename T::tag_type, typename mpl::negate<typename T::value_type>::type> type; |
| }; |
| }; |
| |
| } // namespace mpl |
| |
| namespace units { |
| |
| namespace detail { |
| |
| template<int N> |
| struct make_heterogeneous_system_impl |
| { |
| template<class UnitsBegin, class ExponentsBegin> |
| struct apply |
| { |
| typedef typename push_front_if<!(is_zero<typename ExponentsBegin::item>::value)>::template apply< |
| typename make_heterogeneous_system_impl<N-1>::template apply< |
| typename UnitsBegin::next, |
| typename ExponentsBegin::next |
| >::type, |
| heterogeneous_system_dim<typename UnitsBegin::item, typename ExponentsBegin::item> |
| >::type type; |
| }; |
| }; |
| |
| template<> |
| struct make_heterogeneous_system_impl<0> |
| { |
| template<class UnitsBegin, class ExponentsBegin> |
| struct apply |
| { |
| typedef dimensionless_type type; |
| }; |
| }; |
| |
| template<class Dimensions, class System> |
| struct make_heterogeneous_system |
| { |
| typedef typename calculate_base_unit_exponents<typename System::type, Dimensions>::type exponents; |
| BOOST_MPL_ASSERT_MSG((!boost::is_same<exponents, inconsistent>::value), the_specified_dimension_is_not_representible_in_the_given_system, (types<Dimensions, System>)); |
| typedef typename make_heterogeneous_system_impl<System::type::size::value>::template apply< |
| typename System::type, |
| exponents |
| >::type unit_list; |
| typedef heterogeneous_system<heterogeneous_system_impl<unit_list, Dimensions, no_scale> > type; |
| }; |
| |
| template<class Dimensions, class T> |
| struct make_heterogeneous_system<Dimensions, heterogeneous_system<T> > |
| { |
| typedef heterogeneous_system<T> type; |
| }; |
| |
| template<class T0, class T1> |
| struct multiply_systems |
| { |
| typedef heterogeneous_system< |
| heterogeneous_system_impl< |
| typename mpl::times<typename T0::type, typename T1::type>::type, |
| typename mpl::times<typename T0::dimensions, typename T1::dimensions>::type, |
| typename mpl::times<typename T0::scale, typename T1::scale>::type |
| > |
| > type; |
| }; |
| |
| template<class T0, class T1> |
| struct divide_systems |
| { |
| typedef heterogeneous_system< |
| heterogeneous_system_impl< |
| typename mpl::divides<typename T0::type, typename T1::type>::type, |
| typename mpl::divides<typename T0::dimensions, typename T1::dimensions>::type, |
| typename mpl::divides<typename T0::scale, typename T1::scale>::type |
| > |
| > type; |
| }; |
| |
| } // namespace detail |
| |
| /// INTERNAL ONLY |
| template<class S, long N, long D> |
| struct static_power<heterogeneous_system<S>, static_rational<N,D> > |
| { |
| typedef heterogeneous_system< |
| heterogeneous_system_impl< |
| typename static_power<typename S::type, static_rational<N,D> >::type, |
| typename static_power<typename S::dimensions, static_rational<N,D> >::type, |
| typename static_power<typename S::scale, static_rational<N,D> >::type |
| > |
| > type; |
| }; |
| |
| /// INTERNAL ONLY |
| template<class S, long N, long D> |
| struct static_root<heterogeneous_system<S>, static_rational<N,D> > |
| { |
| typedef heterogeneous_system< |
| heterogeneous_system_impl< |
| typename static_root<typename S::type, static_rational<N,D> >::type, |
| typename static_root<typename S::dimensions, static_rational<N,D> >::type, |
| typename static_root<typename S::scale, static_rational<N,D> >::type |
| > |
| > type; |
| }; |
| |
| namespace detail { |
| |
| template<int N> |
| struct unscale_heterogeneous_system_impl |
| { |
| template<class Begin> |
| struct apply |
| { |
| typedef typename push_front_or_add< |
| typename unscale_heterogeneous_system_impl<N-1>::template apply< |
| typename Begin::next |
| >::type, |
| typename unscale<typename Begin::item>::type |
| >::type type; |
| }; |
| }; |
| |
| template<> |
| struct unscale_heterogeneous_system_impl<0> |
| { |
| template<class Begin> |
| struct apply |
| { |
| typedef dimensionless_type type; |
| }; |
| }; |
| |
| } // namespace detail |
| |
| /// Unscale all the base units. e.g |
| /// km s -> m s |
| /// cm km -> m^2 |
| /// INTERNAL ONLY |
| template<class T> |
| struct unscale<heterogeneous_system<T> > |
| { |
| typedef heterogeneous_system< |
| heterogeneous_system_impl< |
| typename detail::unscale_heterogeneous_system_impl< |
| T::type::size::value |
| >::template apply< |
| typename T::type |
| >::type, |
| typename T::dimensions, |
| no_scale |
| > |
| > type; |
| }; |
| |
| /// INTERNAL ONLY |
| template<class Unit, class Exponent> |
| struct unscale<heterogeneous_system_dim<Unit, Exponent> > |
| { |
| typedef heterogeneous_system_dim<typename unscale<Unit>::type, Exponent> type; |
| }; |
| |
| namespace detail { |
| |
| template<int N> |
| struct get_scale_list_of_heterogeneous_system_impl |
| { |
| template<class Begin> |
| struct apply |
| { |
| typedef typename mpl::times< |
| typename get_scale_list_of_heterogeneous_system_impl<N-1>::template apply< |
| typename Begin::next |
| >::type, |
| typename get_scale_list<typename Begin::item>::type |
| >::type type; |
| }; |
| }; |
| |
| template<> |
| struct get_scale_list_of_heterogeneous_system_impl<0> |
| { |
| template<class Begin> |
| struct apply |
| { |
| typedef dimensionless_type type; |
| }; |
| }; |
| |
| } // namespace detail |
| |
| /// INTERNAL ONLY |
| template<class T> |
| struct get_scale_list<heterogeneous_system<T> > |
| { |
| typedef typename mpl::times< |
| typename detail::get_scale_list_of_heterogeneous_system_impl< |
| T::type::size::value |
| >::template apply<typename T::type>::type, |
| typename T::scale |
| >::type type; |
| }; |
| |
| /// INTERNAL ONLY |
| template<class Unit, class Exponent> |
| struct get_scale_list<heterogeneous_system_dim<Unit, Exponent> > |
| { |
| typedef typename static_power<typename get_scale_list<Unit>::type, Exponent>::type type; |
| }; |
| |
| namespace detail { |
| |
| template<class System, class Dimension> |
| struct check_system : mpl::false_ {}; |
| |
| template<class System, class Dimension, class Scale> |
| struct check_system<heterogeneous_system<heterogeneous_system_impl<System, Dimension, Scale> >, Dimension> : mpl::true_ {}; |
| |
| } // namespace detail |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| #endif |