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 429