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_units_1.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::energy> E1;
36 BOOST_TEST(E1.value() == double());
37
38 // value_type constructor
39 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy> E2(E_*bu::joules);
40 BOOST_TEST(E2.value() == E_);
41
42 // copy constructor
43 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy> E3(E2);
44 BOOST_TEST(E3.value() == E_);
45
46 // operator=
47 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy> E4 = E2;
48 BOOST_TEST(E4.value() == E_);
49
50 // implicit copy constructor value_type conversion
51 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy,float> E5(E2);
52 BOOST_UNITS_CHECK_CLOSE(E5.value(),float(E_));
53
54 // implicit operator= value_type conversion
55 //BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy,float> E7 = E2;
56 //BOOST_UNITS_CHECK_CLOSE(E7.value(),float(E_));
57
58 //BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy,long> E8 = E2;
59 //BOOST_TEST(E8.value() == long(E_));
60
61 // const construction
62 bu::quantity<bu::energy> E9(E2);
63 BOOST_TEST(E9.value() == E_);
64
65 // value assignment
66 bu::quantity_cast<double&>(source&: E9) = 1.5;
67 BOOST_TEST(E9.value() == 1.5);
68
69 // value assignment with implicit value_type conversion
70 bu::quantity_cast<double&>(source&: E9) = 2;
71 BOOST_TEST(E9.value() == double(2));
72
73 // operator+=(this_type)
74 E9 = 2.0*bu::joules;
75 E9 += E9;
76 BOOST_TEST(E9.value() == 4.0);
77
78 // operator-=(this_type)
79 E9 = 2.0*bu::joules;
80 E9 -= E9;
81 BOOST_TEST(E9.value() == 0.0);
82
83 // operator*=(value_type)
84 E9 = 2.0*bu::joules;
85 E9 *= 2.0;
86 BOOST_TEST(E9.value() == 4.0);
87
88 // operator/=(value_type)
89 E9 = 2.0*bu::joules;
90 E9 /= 2.0;
91 BOOST_TEST(E9.value() == 1.0);
92
93 // static construct quantity from value_type
94 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::energy> E(bu::quantity<bu::energy>::from_value(val: 2.5));
95 BOOST_TEST(E.value() == 2.5);
96
97 // quantity_cast
98
99 // unit * scalar
100 BOOST_TEST(bu::joules*2.0 == bu::quantity<bu::energy>::from_value(2.0));
101
102 // unit / scalar
103 BOOST_TEST(bu::joules/2.0 == bu::quantity<bu::energy>::from_value(0.5));
104
105 // scalar * unit
106 BOOST_TEST(2.0*bu::joules == bu::quantity<bu::energy>::from_value(2.0));
107
108 // scalar / unit
109 BOOST_TEST(2.0/bu::joules == bu::quantity<bu::inverse_energy>::from_value(2.0));
110
111 // quantity * scalar
112 BOOST_TEST(E*2.0 == bu::quantity<bu::energy>::from_value(5.0));
113
114 // quantity / scalar
115 BOOST_TEST(E/2.0 == bu::quantity<bu::energy>::from_value(1.25));
116
117 // scalar * quantity
118 BOOST_TEST(2.0*E == bu::quantity<bu::energy>::from_value(5.0));
119
120 // scalar / quantity
121 BOOST_TEST(2.0/E == bu::quantity<bu::inverse_energy>::from_value(0.8));
122
123 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::length> L(1.0*bu::meters);
124 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::mass> M(2.0*bu::kilograms);
125 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::time> T(3.0*bu::seconds);
126 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::velocity> V(bu::quantity<bu::velocity>::from_value(val: 4.0));
127
128 // unit * quantity
129 BOOST_TEST(bu::seconds*V == 4.0*bu::meters);
130
131 // unit / quantity
132 BOOST_TEST(bu::meters/V == 0.25*bu::seconds);
133
134 // quantity * unit
135 BOOST_TEST(V*bu::seconds == 4.0*bu::meters);
136
137 // quantity / unit
138 BOOST_TEST(V/bu::meters == 4.0/bu::seconds);
139
140 // +quantity
141 BOOST_TEST(+V == 4.0*bu::meters_per_second);
142
143 // -quantity
144 BOOST_TEST(-V == -4.0*bu::meters_per_second);
145
146 // quantity + quantity
147 BOOST_TEST(V+V == 8.0*bu::meters_per_second);
148
149 // quantity - quantity
150 BOOST_TEST(V-V == 0.0*bu::meters_per_second);
151
152 // quantity * quantity
153 BOOST_TEST(V*T == 12.0*bu::meters);
154
155 // quantity / quantity
156 BOOST_TEST(L/V == 0.25*bu::seconds);
157
158 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::area> A(2.0*bu::square_meters);
159 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::volume> VL(1.0*bu::cubic_meters);
160
161 // integer power of quantity
162 BOOST_TEST(2.0*bu::pow<2>(L) == A);
163
164 // rational power of quantity
165 BOOST_TEST((bu::pow< bu::static_rational<2,3> >(VL) == 0.5*A));
166
167 // integer root of quantity
168 BOOST_TEST(bu::root<2>(A) == std::sqrt(2.0)*L);
169
170 // rational root of quantity
171 BOOST_TEST((bu::root< bu::static_rational<3,2> >(VL) == 0.5*A));
172
173 BOOST_CONSTEXPR_OR_CONST bu::quantity<bu::area> A1(0.0*bu::square_meters),
174 A2(0.0*bu::square_meters),
175 A3(1.0*bu::square_meters),
176 A4(-1.0*bu::square_meters);
177
178 // operator==
179 BOOST_TEST((A1 == A2) == true);
180 BOOST_TEST((A1 == A3) == false);
181
182 // operator!=
183 BOOST_TEST((A1 != A2) == false);
184 BOOST_TEST((A1 != A3) == true);
185
186 // operator<
187 BOOST_TEST((A1 < A2) == false);
188 BOOST_TEST((A1 < A3) == true);
189
190 // operator<=
191 BOOST_TEST((A1 <= A2) == true);
192 BOOST_TEST((A1 <= A3) == true);
193
194 // operator>
195 BOOST_TEST((A1 > A2) == false);
196 BOOST_TEST((A1 > A4) == true);
197
198 // operator>=
199 BOOST_TEST((A1 >= A2) == true);
200 BOOST_TEST((A1 >= A4) == true);
201
202 return boost::report_errors();
203}
204

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