]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | /** | |
12 | \file | |
13 | ||
14 | \brief test_dimensionless_quantity.cpp | |
15 | ||
16 | \details | |
17 | Test unit class. | |
18 | ||
19 | Output: | |
20 | @verbatim | |
21 | @endverbatim | |
22 | **/ | |
23 | ||
24 | #include "test_header.hpp" | |
25 | ||
26 | #include <boost/units/pow.hpp> | |
27 | ||
28 | namespace bu = boost::units; | |
29 | ||
11fdf7f2 | 30 | BOOST_STATIC_CONSTEXPR double E_ = 2.718281828459045235360287471352662497757; |
7c673cae FG |
31 | |
32 | int test_main(int,char *[]) | |
33 | { | |
34 | // default constructor | |
11fdf7f2 | 35 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> E1; |
7c673cae FG |
36 | BOOST_CHECK(E1.value() == double()); |
37 | ||
38 | // value_type constructor | |
11fdf7f2 | 39 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> E2(E_); |
7c673cae FG |
40 | BOOST_CHECK(E2.value() == E_); |
41 | ||
42 | // copy constructor | |
11fdf7f2 | 43 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> E3(E2); |
7c673cae FG |
44 | BOOST_CHECK(E3.value() == E_); |
45 | ||
46 | // operator= | |
11fdf7f2 | 47 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> E4 = E2; |
7c673cae FG |
48 | BOOST_CHECK(E4.value() == E_); |
49 | ||
50 | // implicit copy constructor value_type conversion | |
11fdf7f2 | 51 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless,float> E5(E2); |
7c673cae FG |
52 | BOOST_UNITS_CHECK_CLOSE(E5.value(), float(E_)); |
53 | ||
11fdf7f2 | 54 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless,long> E6(E2); |
7c673cae FG |
55 | BOOST_CHECK(E6.value() == long(E_)); |
56 | ||
57 | // implicit operator= value_type conversion | |
58 | // narrowing conversion disallowed | |
11fdf7f2 | 59 | // BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless,float> E7 = E2; |
7c673cae FG |
60 | // BOOST_UNITS_CHECK_CLOSE(E7.value(),float(E_)); |
61 | ||
62 | // narrowing conversion disallowed | |
11fdf7f2 | 63 | // BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless,long> E8 = E2; |
7c673cae FG |
64 | // BOOST_CHECK(E8.value() == long(E_)); |
65 | ||
66 | // const construction | |
67 | bu::quantity<bu::dimensionless> E9(E2); | |
68 | BOOST_CHECK(E9.value() == E_); | |
69 | ||
70 | // // value assignment | |
71 | // E9.value() = 1.5*bu::dimensionless(); | |
72 | // BOOST_CHECK(E9.value() == 1.5); | |
73 | // | |
74 | // // value assignment with implicit conversion | |
75 | // E9.value() = 1.5; | |
76 | // BOOST_CHECK(E9.value() == 1.5); | |
77 | // | |
78 | // // value assignment with implicit value_type conversion | |
79 | // E9.value() = 2*bu::dimensionless(); | |
80 | // BOOST_CHECK(E9.value() == double(2)); | |
81 | // | |
82 | // // value assignment with implicit value_type conversion | |
83 | // E9.value() = 2; | |
84 | // BOOST_CHECK(E9.value() == double(2)); | |
85 | ||
86 | // operator+=(this_type) | |
87 | E9 = 2.0; | |
88 | E9 += E9; | |
89 | BOOST_CHECK(E9.value() == 4.0); | |
90 | ||
91 | // operator-=(this_type) | |
92 | E9 = 2.0; | |
93 | E9 -= E9; | |
94 | BOOST_CHECK(E9.value() == 0.0); | |
95 | ||
96 | // operator*=(value_type) | |
97 | E9 = 2.0; | |
98 | E9 *= 2.0; | |
99 | BOOST_CHECK(E9.value() == 4.0); | |
100 | ||
101 | // operator/=(value_type) | |
102 | E9 = 2.0; | |
103 | E9 /= 2.0; | |
104 | BOOST_CHECK(E9.value() == 1.0); | |
105 | ||
106 | // static construct quantity from value_type | |
11fdf7f2 | 107 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> E(bu::quantity<bu::dimensionless>::from_value(2.5)); |
7c673cae FG |
108 | BOOST_CHECK(E.value() == 2.5); |
109 | ||
110 | // implicit conversion to value_type | |
111 | const double V1(E9); | |
112 | BOOST_CHECK(V1 == E9.value()); | |
113 | ||
114 | const double V2 = E9; | |
115 | BOOST_CHECK(V2 == E9.value()); | |
116 | ||
117 | // unit * scalar | |
118 | BOOST_CHECK(bu::dimensionless()*2.0 == bu::quantity<bu::dimensionless>::from_value(2.0)); | |
119 | ||
120 | // unit / scalar | |
121 | BOOST_CHECK(bu::dimensionless()/2.0 == bu::quantity<bu::dimensionless>::from_value(0.5)); | |
122 | ||
123 | // scalar * unit | |
124 | BOOST_CHECK(2.0*bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0)); | |
125 | ||
126 | // scalar / unit | |
127 | BOOST_CHECK(2.0/bu::dimensionless() == bu::quantity<bu::dimensionless>::from_value(2.0)); | |
128 | ||
129 | // quantity * scalar | |
130 | BOOST_CHECK(E*2.0 == bu::quantity<bu::dimensionless>::from_value(5.0)); | |
131 | ||
132 | // quantity / scalar | |
133 | BOOST_CHECK(E/2.0 == bu::quantity<bu::dimensionless>::from_value(1.25)); | |
134 | ||
135 | // scalar * quantity | |
136 | BOOST_CHECK(2.0*E == bu::quantity<bu::dimensionless>::from_value(5.0)); | |
137 | ||
138 | // scalar / quantity | |
139 | BOOST_CHECK(2.0/E == bu::quantity<bu::dimensionless>::from_value(0.8)); | |
140 | ||
11fdf7f2 TL |
141 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> D1(1.0), |
142 | D2(2.0); | |
7c673cae FG |
143 | |
144 | // unit * quantity | |
145 | BOOST_CHECK(bu::dimensionless()*D1 == D1); | |
146 | ||
147 | // unit / quantity | |
148 | BOOST_CHECK(bu::dimensionless()/D1 == D1); | |
149 | ||
150 | // quantity * unit | |
151 | BOOST_CHECK(D1*bu::dimensionless() == D1); | |
152 | ||
153 | // quantity / unit | |
154 | BOOST_CHECK(D1*bu::dimensionless() == D1); | |
155 | ||
156 | // +quantity | |
157 | BOOST_CHECK(+D1 == 1.0*bu::dimensionless()); | |
158 | ||
159 | // -quantity | |
160 | BOOST_CHECK(-D1 == -1.0*bu::dimensionless()); | |
161 | ||
162 | // quantity + quantity | |
163 | BOOST_CHECK(D2+D1 == 3.0*bu::dimensionless()); | |
164 | ||
165 | // quantity - quantity | |
166 | BOOST_CHECK(D2-D1 == 1.0*bu::dimensionless()); | |
167 | ||
168 | // quantity * quantity | |
169 | BOOST_CHECK(D1*D2 == 2.0*bu::dimensionless()); | |
170 | ||
171 | // quantity / quantity | |
172 | BOOST_CHECK(D2/D1 == 2.0*bu::dimensionless()); | |
173 | ||
174 | // integer power of quantity | |
175 | BOOST_CHECK(2.0*bu::pow<2>(D2) == 2.0*std::pow(2.0,2.0)*bu::dimensionless()); | |
176 | ||
177 | // rational power of quantity | |
178 | BOOST_CHECK((2.0*bu::pow< bu::static_rational<2,3> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless())); | |
179 | ||
180 | // integer root of quantity | |
181 | BOOST_CHECK(2.0*bu::root<2>(D2) == 2.0*std::pow(2.0,1.0/2.0)*bu::dimensionless()); | |
182 | ||
183 | // rational root of quantity | |
184 | BOOST_CHECK((2.0*bu::root< bu::static_rational<3,2> >(D2) == 2.0*std::pow(2.0,2.0/3.0)*bu::dimensionless())); | |
185 | ||
11fdf7f2 TL |
186 | BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::dimensionless> A1(0.0), |
187 | A2(0.0), | |
188 | A3(1.0), | |
189 | A4(-1.0); | |
7c673cae FG |
190 | |
191 | // operator== | |
192 | BOOST_CHECK((A1 == A2) == true); | |
193 | BOOST_CHECK((A1 == A3) == false); | |
194 | ||
195 | // operator!= | |
196 | BOOST_CHECK((A1 != A2) == false); | |
197 | BOOST_CHECK((A1 != A3) == true); | |
198 | ||
199 | // operator< | |
200 | BOOST_CHECK((A1 < A2) == false); | |
201 | BOOST_CHECK((A1 < A3) == true); | |
202 | ||
203 | // operator<= | |
204 | BOOST_CHECK((A1 <= A2) == true); | |
205 | BOOST_CHECK((A1 <= A3) == true); | |
206 | ||
207 | // operator> | |
208 | BOOST_CHECK((A1 > A2) == false); | |
209 | BOOST_CHECK((A1 > A4) == true); | |
210 | ||
211 | // operator>= | |
212 | BOOST_CHECK((A1 >= A2) == true); | |
213 | BOOST_CHECK((A1 >= A4) == true); | |
214 | ||
215 | return 0; | |
216 | } |