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
42namespace boost {
43
44namespace units {
45
46namespace 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
53template<class T>
54struct is_zero : mpl::false_ {};
55
56template<>
57struct is_zero<static_rational<0> > : mpl::true_ {};
58
59} // namespace detail
60
61/// INTERNAL ONLY
62template<class L, class Dimensions, class Scale>
63struct heterogeneous_system_impl
64{
65 typedef L type;
66 typedef Dimensions dimensions;
67 typedef Scale scale;
68};
69
70/// INTERNAL ONLY
71typedef 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.
78template<class T>
79struct heterogeneous_system : T {};
80
81/// INTERNAL ONLY
82struct heterogeneous_system_dim_tag {};
83
84/// INTERNAL ONLY
85template<class Unit, class Exponent>
86struct 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
122BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_impl, (class)(class)(class))
123BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system, (class))
124BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_dim, (class)(class))
125
126#endif
127
128namespace boost {
129
130namespace mpl {
131
132/// INTERNAL ONLY
133template<>
134struct 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
142namespace units {
143
144namespace detail {
145
146template<class Unit1, class Exponent1>
147struct is_empty_dim<heterogeneous_system_dim<Unit1,Exponent1> > : detail::is_zero<Exponent1> {};
148
149} // namespace detail
150
151} // namespace units
152
153namespace mpl {
154
155/// INTERNAL ONLY
156template<>
157struct 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
170template<>
171struct 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
184template<>
185struct 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
198template<>
199struct 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
210namespace units {
211
212namespace detail {
213
214template<int N>
215struct 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
230template<>
231struct make_heterogeneous_system_impl<0>
232{
233 template<class UnitsBegin, class ExponentsBegin>
234 struct apply
235 {
236 typedef dimensionless_type type;
237 };
238};
239
240template<class Dimensions, class System>
241struct 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
252template<class Dimensions, class T>
253struct make_heterogeneous_system<Dimensions, heterogeneous_system<T> >
254{
255 typedef heterogeneous_system<T> type;
256};
257
258template<class T0, class T1>
259struct 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
270template<class T0, class T1>
271struct 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
285template<class S, long N, long D>
286struct 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
298template<class S, long N, long D>
299struct 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
310namespace detail {
311
312template<int N>
313struct 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
327template<>
328struct 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
343template<class T>
344struct 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
360template<class Unit, class Exponent>
361struct unscale<heterogeneous_system_dim<Unit, Exponent> >
362{
363 typedef heterogeneous_system_dim<typename unscale<Unit>::type, Exponent> type;
364};
365
366namespace detail {
367
368template<int N>
369struct 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
383template<>
384struct 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
396template<class T>
397struct 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
408template<class Unit, class Exponent>
409struct 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
414namespace detail {
415
416template<class System, class Dimension>
417struct check_system : mpl::false_ {};
418
419template<class System, class Dimension, class Scale>
420struct 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

source code of boost/libs/units/include/boost/units/heterogeneous_system.hpp