]>
Commit | Line | Data |
---|---|---|
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 |