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) 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 | // $Id: test_lambda.cpp 27 2008-06-16 14:50:58Z maehne $ |
12 | |
13 | //////////////////////////////////////////////////////////////////////// |
14 | /// |
15 | /// \file test_lambda.hpp |
16 | /// |
17 | /// \brief Unit test for checking the usage of Boost.Units' quantity, |
18 | /// unit, and absolute types in functors created with the |
19 | /// Boost.Lambda library. |
20 | /// |
21 | /// \author Torsten Maehne |
22 | /// \date 2008-06-16 |
23 | /// |
24 | /// This unit test contains a check for each operator action, for |
25 | /// which a specialization of Boost.Lambda's return type deduction |
26 | /// system is made in lambda.hpp, i.e., for the operators defined for |
27 | /// Boost.Units' quantity, unit, and absolute types. |
28 | /// |
29 | //////////////////////////////////////////////////////////////////////// |
30 | |
31 | #include <boost/function.hpp> |
32 | #include <boost/units/lambda.hpp> |
33 | #include <boost/units/absolute.hpp> |
34 | #include <boost/units/systems/si/temperature.hpp> |
35 | #include "test_header.hpp" |
36 | |
37 | |
38 | namespace bl = boost::lambda; |
39 | namespace bu = boost::units; |
40 | namespace si = boost::units::si; |
41 | |
42 | |
43 | int main() |
44 | { |
45 | |
46 | //////////////////////////////////////////////////////////////////////// |
47 | // Test for Boost.Lambda working with overloaded operators defined |
48 | // in <boost/units/quantity.hpp> |
49 | //////////////////////////////////////////////////////////////////////// |
50 | |
51 | bu::quantity<bu::length> lvar = 0.0 * bu::meter; |
52 | |
53 | bu::quantity<bu::dimensionless> dlvar = 3.0; |
54 | |
55 | // quantity<Unit, Y> += quantity<Unit2, YY> |
56 | boost::function<bu::quantity<bu::length> (bu::quantity<bu::length>)> |
57 | f = (bl::var(t&: lvar) += bl::_1); |
58 | |
59 | lvar = 1.0 * bu::meter; |
60 | BOOST_TEST((f(2.0 * bu::meter) == 3.0 * bu::meter)); |
61 | BOOST_TEST((f(6.0 * bu::meter) == 9.0 * bu::meter)); |
62 | |
63 | // quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> += quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> |
64 | dlvar = 4.0; |
65 | BOOST_TEST(((bl::var(dlvar) += bl::_1)(3.0) == 7.0)); |
66 | |
67 | // quantity<Unit, Y> -= quantity<Unit2, YY> |
68 | lvar = 3.0 * bu::meter; |
69 | BOOST_TEST((f(-2.0 * bu::meter) == 1.0 * bu::meter)); |
70 | BOOST_TEST((f(6.0 * bu::meter) == 7.0 * bu::meter)); |
71 | |
72 | // quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> -= quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> |
73 | dlvar = 4.0; |
74 | BOOST_TEST(((bl::var(dlvar) -= bl::_1)(3.0) == 1.0)); |
75 | |
76 | // quantity<Unit, Y> *= quantity<Unit2, YY> |
77 | dlvar = 2.0; |
78 | BOOST_TEST(((bl::var(dlvar) *= bl::_1)(3.0) == 6.0)); |
79 | |
80 | // quantity<Unit, Y> /= quantity<Unit2, YY> |
81 | dlvar = 6.0; |
82 | BOOST_TEST(((bl::var(dlvar) /= bl::_1)(3.0) == 2.0)); |
83 | |
84 | // quantity<Unit, Y> *= Y |
85 | lvar = 3.0 * bu::meter; |
86 | BOOST_TEST(((bl::var(lvar) *= bl::_1)(2.0) == 6.0 * bu::meter)); |
87 | |
88 | // quantity<Unit, Y> /= Y |
89 | lvar = 6.0 * bu::meter; |
90 | BOOST_TEST(((bl::var(lvar) /= bl::_1)(3.0) == 2.0 * bu::meter)); |
91 | |
92 | // unit<Dim, System> * Y |
93 | BOOST_TEST(((bl::_1 * bl::_2)(bu::meter, 2.0) == 2.0 * bu::meter)); |
94 | BOOST_TEST(((bu::meter * bl::_1)(2.0) == 2.0 * bu::meter)); |
95 | |
96 | // unit<Dim, System> / Y |
97 | BOOST_TEST(((bl::_1 / bl::_2)(bu::meter, 0.5) == 2.0 * bu::meter)); |
98 | BOOST_TEST(((bu::meter / bl::_1)(0.5 * bu::second) == 2.0 * bu::meter_per_second)); |
99 | |
100 | // Y * unit<Dim, System> |
101 | BOOST_TEST(((bl::_1 * bl::_2)(2.0, bu::meter) == 2.0 * bu::meter)); |
102 | BOOST_TEST(((bl::_1 * bu::meter)(2.0 / bu::second) == 2.0 * bu::meter_per_second)); |
103 | |
104 | // Y / unit<Dim, System> |
105 | BOOST_TEST(((bl::_1 / bl::_2)(3.5, bu::second) == 3.5 / bu::second)); |
106 | BOOST_TEST(((bl::_1 / bu::second)(3.5 * bu::meter) == 3.5 * bu::meter_per_second)); |
107 | |
108 | // quantity<Unit, X> * X |
109 | BOOST_TEST(((bl::_1 * bl::_2)(2.0, 3.0 * bu::meter) == 6.0 * bu::meter)); |
110 | |
111 | // X * quantity<Unit, X> |
112 | BOOST_TEST(((bl::_1 * bl::_2)(4.0 * bu::joule, 2.0) == 8.0 * bu::joule)); |
113 | |
114 | // quantity<Unit, X> / X |
115 | BOOST_TEST(((bl::_1 / bl::_2)(4.0 * bu::joule, 2.0) == 2.0 * bu::joule)); |
116 | |
117 | // X / quantity<Unit, X> |
118 | BOOST_TEST(((3.0 / bl::_1)(2.0 * bu::second) == 1.5 / bu::second)); |
119 | |
120 | // unit<Dim1, System1> * quantity<Unit2, Y> |
121 | BOOST_TEST(((bl::_1 * bl::_2)(bu::meter, 12.0 / bu::second) == 12.0 * bu::meter_per_second)); |
122 | BOOST_TEST(((bu::meter * bl::_1)(12.0 / bu::second) == 12.0 * bu::meter_per_second)); |
123 | |
124 | // unit<Dim1, System1> / quantity<Unit2, Y> |
125 | BOOST_TEST(((bl::_1 / bl::_2)(bu::meter, 0.5 * bu::second) == 2.0 * bu::meter_per_second)); |
126 | BOOST_TEST(((bu::meter / bl::_1)(0.25 * bu::second) == 4.0 * bu::meter_per_second)); |
127 | |
128 | // quantity<Unit1, Y> * unit<Dim2, System2> |
129 | BOOST_TEST(((bl::_1 * bl::_2)(2.0 / bu::second, bu::meter) == 2.0 * bu::meter_per_second)); |
130 | BOOST_TEST(((bl::_1 * bu::meter)(12.0 / bu::second) == 12.0 * bu::meter_per_second)); |
131 | |
132 | // quantity<Unit1, Y> / unit<Dim2, System2> |
133 | BOOST_TEST(((bl::_1 / bl::_2)(3.5 * bu::meter, bu::second) == 3.5 * bu::meter_per_second)); |
134 | BOOST_TEST(((bl::_1 / bu::second)(5.0 * bu::second) == 5.0)); |
135 | |
136 | // +quantity<Unit, Y> |
137 | BOOST_TEST(((+bl::_1)(5.0 * bu::second) == 5.0 * bu::second)); |
138 | |
139 | // -quantity<Unit, Y> |
140 | BOOST_TEST(((-bl::_1)(5.0 * bu::second) == -5.0 * bu::second)); |
141 | |
142 | // quantity<Unit1, X> + quantity<Unit2, Y> |
143 | BOOST_TEST(((bl::_1 + bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == 6.0 * bu::meter)); |
144 | |
145 | // quantity<dimensionless, X> + Y |
146 | BOOST_TEST(((bl::_1 + 1.0f)(bu::quantity<bu::dimensionless>(2.0)) == 3.0)); |
147 | |
148 | // X + quantity<dimensionless, Y> |
149 | BOOST_TEST(((1.0f + bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 2.0)); |
150 | |
151 | // quantity<Unit1, X> - quantity<Unit2, Y> |
152 | BOOST_TEST(((bl::_1 - bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == -2.0 * bu::meter)); |
153 | |
154 | // quantity<dimensionless, X> - Y |
155 | BOOST_TEST(((bl::_1 - 2.0f)(bu::quantity<bu::dimensionless>(1.0)) == -1.0)); |
156 | |
157 | // X - quantity<dimensionless, Y> |
158 | BOOST_TEST(((2.0f - bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 1.0)); |
159 | |
160 | // quantity<Unit1, X> * quantity<Unit2, Y> |
161 | BOOST_TEST(((bl::_1 * bl::_2)(2.0 * bu::kilogram, 4.0 * bu::meter_per_second) == 8.0 * bu::kilogram * bu::meter_per_second)); |
162 | |
163 | // quantity<Unit1, X> / quantity<Unit2, Y> |
164 | BOOST_TEST(((bl::_1 / bl::_2)(2.0 * bu::meter_per_second, 4.0 * bu::meter_per_second) == 0.5)); |
165 | |
166 | // quantity<Unit, X> == quantity<Unit, Y> |
167 | BOOST_TEST(((bl::_1 == bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == true)); |
168 | BOOST_TEST(((bl::_1 == bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == false)); |
169 | |
170 | // quantity<Unit, X> != quantity<Unit, Y> |
171 | BOOST_TEST(((bl::_1 != bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == false)); |
172 | BOOST_TEST(((bl::_1 != bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == true)); |
173 | |
174 | // quantity<Unit, X> < quantity<Unit, Y> |
175 | BOOST_TEST(((bl::_1 < bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == false)); |
176 | BOOST_TEST(((bl::_1 < bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == true)); |
177 | |
178 | // quantity<Unit, X> <= quantity<Unit, Y> |
179 | BOOST_TEST(((bl::_1 <= bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == true)); |
180 | BOOST_TEST(((bl::_1 <= bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == true)); |
181 | BOOST_TEST(((bl::_1 <= bl::_2)(4.0 * bu::meter, 3.0 * bu::meter) == false)); |
182 | |
183 | // quantity<Unit, X> > quantity<Unit, Y> |
184 | BOOST_TEST(((bl::_1 > bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == false)); |
185 | BOOST_TEST(((bl::_1 > bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == false)); |
186 | BOOST_TEST(((bl::_1 > bl::_2)(4.0 * bu::meter, 3.0 * bu::meter) == true)); |
187 | |
188 | // quantity<Unit, X> >= quantity<Unit, Y> |
189 | BOOST_TEST(((bl::_1 >= bl::_2)(2.0 * bu::meter, 2.0 * bu::meter) == true)); |
190 | BOOST_TEST(((bl::_1 >= bl::_2)(2.0 * bu::meter, 3.0 * bu::meter) == false)); |
191 | BOOST_TEST(((bl::_1 >= bl::_2)(4.0 * bu::meter, 3.0 * bu::meter) == true)); |
192 | |
193 | |
194 | //////////////////////////////////////////////////////////////////////// |
195 | // Test for Boost.Lambda working with overloaded operators defined |
196 | // in <boost/units/unit.hpp> |
197 | //////////////////////////////////////////////////////////////////////// |
198 | |
199 | // +unit<Dim, System> |
200 | BOOST_TEST(((+bl::_1)(bu::meter) == bu::meter)); |
201 | |
202 | // -unit<Dim, System> |
203 | BOOST_TEST(((-bl::_1)(bu::meter) == bu::meter)); |
204 | |
205 | // unit<Dim1, System1> + unit<Dim2, System2> |
206 | BOOST_TEST(((bl::_1 + bu::meter)(bu::meter) == bu::meter)); |
207 | BOOST_TEST(((bu::meter + bl::_1)(bu::meter) == bu::meter)); |
208 | BOOST_TEST(((bl::_1 + bl::_2)(bu::meter, bu::meter) == bu::meter)); |
209 | |
210 | // unit<Dim1, System1> - unit<Dim2, System2> |
211 | BOOST_TEST(((bl::_1 - bl::_2)(bu::meter, bu::meter) == bu::meter)); |
212 | BOOST_TEST(((bl::_1 - bu::meter)(bu::meter) == bu::meter)); |
213 | BOOST_TEST(((bu::meter - bl::_1)(bu::meter) == bu::meter)); |
214 | |
215 | // unit<Dim1, System1> * unit<Dim2, System2> |
216 | BOOST_TEST(((bl::_1 * bl::_2)(bu::meter, bu::meter) == bu::meter * bu::meter)); |
217 | BOOST_TEST(((bl::_1 * bu::meter)(bu::meter) == bu::meter * bu::meter)); |
218 | |
219 | // unit<Dim1, System1> / unit<Dim2, System2> |
220 | BOOST_TEST(((bl::_1 / bl::_2)(bu::meter, bu::second) == bu::meter_per_second)); |
221 | BOOST_TEST(((bl::_1 / bu::second)(bu::meter) == bu::meter_per_second)); |
222 | |
223 | // unit<Dim1, System1> == unit<Dim2, System2> |
224 | BOOST_TEST(((bl::_1 == bu::meter)(bu::meter) == true)); |
225 | BOOST_TEST(((bl::_1 == bu::meter)(bu::second) == false)); |
226 | |
227 | // unit<Dim1, System1> != unit<Dim2, System2> |
228 | BOOST_TEST(((bl::_1 != bu::meter)(bu::meter) == false)); |
229 | BOOST_TEST(((bl::_1 != bu::meter)(bu::second) == true)); |
230 | |
231 | |
232 | //////////////////////////////////////////////////////////////////////// |
233 | // Test for Boost.Lambda working with overloaded operators defined |
234 | // in <boost/units/absolute.hpp> |
235 | //////////////////////////////////////////////////////////////////////// |
236 | |
237 | // absolute<Y> += Y |
238 | bu::quantity<bu::absolute<si::temperature> > Ta = 270.0 * bu::absolute<si::temperature>(); |
239 | (Ta += bl::_1)(30.0 * si::kelvin); |
240 | BOOST_TEST(( Ta == 300.0 * bu::absolute<si::temperature>())); |
241 | |
242 | // absolute<Y> -= Y |
243 | Ta = 270 * bu::absolute<si::temperature>(); |
244 | (Ta -= bl::_1)(-30.0 * si::kelvin); |
245 | BOOST_TEST(( Ta == 300.0 * bu::absolute<si::temperature>())); |
246 | |
247 | // absolute<Y> + Y |
248 | BOOST_TEST(((270.0 * bu::absolute<si::temperature>() + bl::_1)(30.0 * si::kelvin) == 300.0 * bu::absolute<si::temperature>())); |
249 | |
250 | // Y + absolute<Y> |
251 | BOOST_TEST(((bl::_1 + 270.0 * bu::absolute<si::temperature>())(30.0 * si::kelvin) == 300.0 * bu::absolute<si::temperature>())); |
252 | |
253 | // absolute<Y> - Y |
254 | BOOST_TEST(((270.0 * bu::absolute<si::temperature>() - bl::_1)(30.0 * si::kelvin) == 240.0 * bu::absolute<si::temperature>())); |
255 | |
256 | // absolute<Y> - absolute<Y> |
257 | BOOST_TEST(((bl::_1 - 270.0 * bu::absolute<si::temperature>())(300.0 * bu::absolute<si::temperature>()) == 30.0 * si::kelvin)); |
258 | |
259 | // T * absolute<unit<D, S> > |
260 | BOOST_TEST(((bl::_1 * bu::absolute<si::temperature>())(300.0) == 300.0 * bu::absolute<si::temperature>())); |
261 | BOOST_TEST(((bl::_1 * bl::_2)(300.0, bu::absolute<si::temperature>()) == 300.0 * bu::absolute<si::temperature>())); |
262 | |
263 | // absolute<unit<D, S> > * T |
264 | BOOST_TEST(((bu::absolute<si::temperature>() * bl::_1)(300.0) == 300.0 * bu::absolute<si::temperature>())); |
265 | BOOST_TEST(((bl::_1 * bl::_2)(bu::absolute<si::temperature>(), 300.0) == 300.0 * bu::absolute<si::temperature>())); |
266 | |
267 | |
268 | return boost::report_errors(); |
269 | } |
270 | |