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

source code of boost/libs/units/test/test_dimensionless_quantity.cpp