boost/units/heterogeneous_system.hpp
// 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