ceph/src/boost/boost/units/heterogeneous_system.hpp

   1 // Boost.Units - A C++ library for zero-overhead dimensional analysis and
   2 // unit/quantity manipulation and conversion
   3 //
   4 // Copyright (C) 2003-2008 Matthias Christian Schabel
   5 // Copyright (C) 2007-2008 Steven Watanabe
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 #ifndef BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP
  12 #define BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP
  13
  14 /// \file
  15 /// \brief A heterogeneous system is a sorted list of base unit/exponent pairs.
  16
  17 #include <boost/mpl/bool.hpp>
  18 #include <boost/mpl/plus.hpp>
  19 #include <boost/mpl/times.hpp>
  20 #include <boost/mpl/divides.hpp>
  21 #include <boost/mpl/negate.hpp>
  22 #include <boost/mpl/less.hpp>
  23 #include <boost/mpl/size.hpp>
  24 #include <boost/mpl/begin.hpp>
  25 #include <boost/mpl/next.hpp>
  26 #include <boost/mpl/deref.hpp>
  27 #include <boost/mpl/front.hpp>
  28 #include <boost/mpl/push_front.hpp>
  29 #include <boost/mpl/pop_front.hpp>
  30 #include <boost/mpl/assert.hpp>
  31 #include <boost/type_traits/is_same.hpp>
  32
  33 #include <boost/units/config.hpp>
  34 #include <boost/units/static_rational.hpp>
  35 #include <boost/units/dimension.hpp>
  36 #include <boost/units/units_fwd.hpp>
  37 #include <boost/units/detail/push_front_if.hpp>
  38 #include <boost/units/detail/push_front_or_add.hpp>
  39 #include <boost/units/detail/linear_algebra.hpp>
  40 #include <boost/units/detail/unscale.hpp>
  41
  42 namespace boost {
  43
  44 namespace units {
  45
  46 namespace detail {
  47
  48 // A normal system is a sorted list of base units.
  49 // A heterogeneous system is a sorted list of base unit/exponent pairs.
  50 // As long as we don't need to convert heterogeneous systems
  51 // directly everything is cool.
  52
  53 template<class T>
  54 struct is_zero : mpl::false_ {};
  55
  56 template<>
  57 struct is_zero<static_rational<0> > : mpl::true_ {};
  58
  59 } // namespace detail
  60
  61 /// INTERNAL ONLY
  62 template<class L, class Dimensions, class Scale>
  63 struct heterogeneous_system_impl
  64 {
  65     typedef L type;
  66     typedef Dimensions dimensions;
  67     typedef Scale scale;
  68 };
  69
  70 /// INTERNAL ONLY
  71 typedef dimensionless_type no_scale;
  72
  73 /// A system that can represent any possible combination
  74 /// of units at the expense of not preserving information
  75 /// about how it was created.  Do not create specializations
  76 /// of this template directly. Instead use @c reduce_unit and
  77 /// @c base_unit<...>::unit_type.
  78 template<class T>
  79 struct heterogeneous_system : T {};
  80
  81 /// INTERNAL ONLY
  82 struct heterogeneous_system_dim_tag {};
  83
  84 /// INTERNAL ONLY
  85 template<class Unit, class Exponent>
  86 struct heterogeneous_system_dim
  87 {
  88     typedef heterogeneous_system_dim_tag tag;
  89     typedef heterogeneous_system_dim type;
  90     typedef Unit tag_type;
  91     typedef Exponent value_type;
  92 };
  93
  94 /// INTERNAL ONLY
  95 #define BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(BaseUnit, Dimensions)   \
  96     boost::units::unit<                                             \
  97         Dimensions,                                                 \
  98         boost::units::heterogeneous_system<                         \
  99             boost::units::heterogeneous_system_impl<                \
 100                 boost::units::list<                       \
 101                     boost::units::heterogeneous_system_dim<         \
 102                         BaseUnit,                                   \
 103                         boost::units::static_rational<1>            \
 104                     >,                                              \
 105                     boost::units::dimensionless_type                \
 106                 >,                                                  \
 107                 Dimensions,                                         \
 108                 boost::units::no_scale                              \
 109             >                                                       \
 110         >                                                           \
 111     >
 112
 113 } // namespace units
 114
 115 } // namespace boost
 116
 117
 118 #if BOOST_UNITS_HAS_BOOST_TYPEOF
 119
 120 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 121
 122 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_impl, (class)(class)(class))
 123 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system, (class))
 124 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_dim, (class)(class))
 125
 126 #endif
 127
 128 namespace boost {
 129
 130 namespace mpl {
 131
 132 /// INTERNAL ONLY
 133 template<>
 134 struct less_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag>
 135 {
 136     template<class T0, class T1>
 137     struct apply : mpl::less<typename T0::tag_type, typename T1::tag_type> {};
 138 };
 139
 140 }
 141
 142 namespace units {
 143
 144 namespace detail {
 145
 146 template<class Unit1, class Exponent1>
 147 struct is_empty_dim<heterogeneous_system_dim<Unit1,Exponent1> > : detail::is_zero<Exponent1> {};
 148
 149 } // namespace detail
 150
 151 } // namespace units
 152
 153 namespace mpl {
 154
 155 /// INTERNAL ONLY
 156 template<>
 157 struct plus_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag>
 158 {
 159     template<class T0, class T1>
 160     struct apply
 161     {
 162         typedef boost::units::heterogeneous_system_dim<
 163             typename T0::tag_type,
 164             typename mpl::plus<typename T0::value_type,typename T1::value_type>::type
 165         > type;
 166     };
 167 };
 168
 169 /// INTERNAL ONLY
 170 template<>
 171 struct times_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag>
 172 {
 173     template<class T0, class T1>
 174     struct apply
 175     {
 176         typedef boost::units::heterogeneous_system_dim<
 177             typename T0::tag_type,
 178             typename mpl::times<typename T0::value_type,T1>::type
 179         > type;
 180     };
 181 };
 182
 183 /// INTERNAL ONLY
 184 template<>
 185 struct divides_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag>
 186 {
 187     template<class T0, class T1>
 188     struct apply
 189     {
 190         typedef boost::units::heterogeneous_system_dim<
 191             typename T0::tag_type,
 192             typename mpl::divides<typename T0::value_type,T1>::type
 193         > type;
 194     };
 195 };
 196
 197 /// INTERNAL ONLY
 198 template<>
 199 struct negate_impl<boost::units::heterogeneous_system_dim_tag>
 200 {
 201     template<class T>
 202     struct apply
 203     {
 204         typedef boost::units::heterogeneous_system_dim<typename T::tag_type, typename mpl::negate<typename T::value_type>::type> type;
 205     };
 206 };
 207
 208 } // namespace mpl
 209
 210 namespace units {
 211
 212 namespace detail {
 213
 214 template<int N>
 215 struct make_heterogeneous_system_impl
 216 {
 217     template<class UnitsBegin, class ExponentsBegin>
 218     struct apply
 219     {
 220         typedef typename push_front_if<!(is_zero<typename ExponentsBegin::item>::value)>::template apply<
 221             typename make_heterogeneous_system_impl<N-1>::template apply<
 222                 typename UnitsBegin::next,
 223                 typename ExponentsBegin::next
 224             >::type,
 225             heterogeneous_system_dim<typename UnitsBegin::item, typename ExponentsBegin::item>
 226         >::type type;
 227     };
 228 };
 229
 230 template<>
 231 struct make_heterogeneous_system_impl<0>
 232 {
 233     template<class UnitsBegin, class ExponentsBegin>
 234     struct apply
 235     {
 236         typedef dimensionless_type type;
 237     };
 238 };
 239
 240 template<class Dimensions, class System>
 241 struct make_heterogeneous_system
 242 {
 243     typedef typename calculate_base_unit_exponents<typename System::type, Dimensions>::type exponents;
 244     BOOST_MPL_ASSERT_MSG((!boost::is_same<exponents, inconsistent>::value), the_specified_dimension_is_not_representible_in_the_given_system, (types<Dimensions, System>));
 245     typedef typename make_heterogeneous_system_impl<System::type::size::value>::template apply<
 246         typename System::type,
 247         exponents
 248     >::type unit_list;
 249     typedef heterogeneous_system<heterogeneous_system_impl<unit_list, Dimensions, no_scale> > type;
 250 };
 251
 252 template<class Dimensions, class T>
 253 struct make_heterogeneous_system<Dimensions, heterogeneous_system<T> >
 254 {
 255     typedef heterogeneous_system<T> type;
 256 };
 257
 258 template<class T0, class T1>
 259 struct multiply_systems
 260 {
 261     typedef heterogeneous_system<
 262         heterogeneous_system_impl<
 263             typename mpl::times<typename T0::type, typename T1::type>::type,
 264             typename mpl::times<typename T0::dimensions, typename T1::dimensions>::type,
 265             typename mpl::times<typename T0::scale, typename T1::scale>::type
 266         >
 267     > type;
 268 };
 269
 270 template<class T0, class T1>
 271 struct divide_systems
 272 {
 273     typedef heterogeneous_system<
 274         heterogeneous_system_impl<
 275             typename mpl::divides<typename T0::type, typename T1::type>::type,
 276             typename mpl::divides<typename T0::dimensions, typename T1::dimensions>::type,
 277             typename mpl::divides<typename T0::scale, typename T1::scale>::type
 278         >
 279     > type;
 280 };
 281
 282 } // namespace detail
 283
 284 /// INTERNAL ONLY
 285 template<class S, long N, long D>
 286 struct static_power<heterogeneous_system<S>, static_rational<N,D> >
 287 {
 288     typedef heterogeneous_system<
 289         heterogeneous_system_impl<
 290             typename static_power<typename S::type, static_rational<N,D> >::type,
 291             typename static_power<typename S::dimensions, static_rational<N,D> >::type,
 292             typename static_power<typename S::scale, static_rational<N,D> >::type
 293         >
 294     > type;
 295 };
 296
 297 /// INTERNAL ONLY
 298 template<class S, long N, long D>
 299 struct static_root<heterogeneous_system<S>, static_rational<N,D> >
 300 {
 301     typedef heterogeneous_system<
 302         heterogeneous_system_impl<
 303             typename static_root<typename S::type, static_rational<N,D> >::type,
 304             typename static_root<typename S::dimensions, static_rational<N,D> >::type,
 305             typename static_root<typename S::scale, static_rational<N,D> >::type
 306         >
 307     > type;
 308 };
 309
 310 namespace detail {
 311
 312 template<int N>
 313 struct unscale_heterogeneous_system_impl
 314 {
 315     template<class Begin>
 316     struct apply
 317     {
 318         typedef typename push_front_or_add<
 319             typename unscale_heterogeneous_system_impl<N-1>::template apply<
 320                 typename Begin::next
 321             >::type,
 322             typename unscale<typename Begin::item>::type
 323         >::type type;
 324     };
 325 };
 326
 327 template<>
 328 struct unscale_heterogeneous_system_impl<0>
 329 {
 330     template<class Begin>
 331     struct apply
 332     {
 333         typedef dimensionless_type type;
 334     };
 335 };
 336
 337 } // namespace detail
 338
 339 /// Unscale all the base units. e.g
 340 /// km s -> m s
 341 /// cm km -> m^2
 342 /// INTERNAL ONLY
 343 template<class T>
 344 struct unscale<heterogeneous_system<T> >
 345 {
 346     typedef heterogeneous_system<
 347         heterogeneous_system_impl<
 348             typename detail::unscale_heterogeneous_system_impl<
 349                 T::type::size::value
 350             >::template apply<
 351                 typename T::type
 352             >::type,
 353             typename T::dimensions,
 354             no_scale
 355         >
 356     > type;
 357 };
 358
 359 /// INTERNAL ONLY
 360 template<class Unit, class Exponent>
 361 struct unscale<heterogeneous_system_dim<Unit, Exponent> >
 362 {
 363     typedef heterogeneous_system_dim<typename unscale<Unit>::type, Exponent> type;
 364 };
 365
 366 namespace detail {
 367
 368 template<int N>
 369 struct get_scale_list_of_heterogeneous_system_impl
 370 {
 371     template<class Begin>
 372     struct apply
 373     {
 374         typedef typename mpl::times<
 375             typename get_scale_list_of_heterogeneous_system_impl<N-1>::template apply<
 376                 typename Begin::next
 377             >::type,
 378             typename get_scale_list<typename Begin::item>::type
 379         >::type type;
 380     };
 381 };
 382
 383 template<>
 384 struct get_scale_list_of_heterogeneous_system_impl<0>
 385 {
 386     template<class Begin>
 387     struct apply
 388     {
 389         typedef dimensionless_type type;
 390     };
 391 };
 392
 393 } // namespace detail
 394
 395 /// INTERNAL ONLY
 396 template<class T>
 397 struct get_scale_list<heterogeneous_system<T> >
 398 {
 399     typedef typename mpl::times<
 400         typename detail::get_scale_list_of_heterogeneous_system_impl<
 401             T::type::size::value
 402         >::template apply<typename T::type>::type,
 403         typename T::scale
 404     >::type type;
 405 };
 406
 407 /// INTERNAL ONLY
 408 template<class Unit, class Exponent>
 409 struct get_scale_list<heterogeneous_system_dim<Unit, Exponent> >
 410 {
 411     typedef typename static_power<typename get_scale_list<Unit>::type, Exponent>::type type;
 412 };
 413
 414 namespace detail {
 415
 416 template<class System, class Dimension>
 417 struct check_system : mpl::false_ {};
 418
 419 template<class System, class Dimension, class Scale>
 420 struct check_system<heterogeneous_system<heterogeneous_system_impl<System, Dimension, Scale> >, Dimension> : mpl::true_ {};
 421
 422 } // namespace detail
 423
 424 } // namespace units
 425
 426 } // namespace boost
 427
 428 #endif