Project
Loading...
Searching...
No Matches
tests.h
Go to the documentation of this file.
1
5
6#pragma once
7#include <cassert>
8#include <SI/literals.h>
9
10namespace SI {
11
13 inline void checkFeatures() {
14 static_assert(3_m == meters(3));
15 static_assert(3_m == 3 * 1_m);
16 static_assert(1_km + 1_m + 1_dm + 1_cm + 1_mm == 1001.111_m);
17 static_assert(1_km / 30_min == 2_km_per_h);
18 static_assert(1_m * 2_m == 2_m²);
19 static_assert(1_m * 2_m * 3_m == 6_m³);
20 static_assert((1_m * 2_m * 3_m) / 2_s == 3_m³_per_s);
21 static_assert(1000 / 1_s == 1_kHz);
22 static_assert(1_Mach == 330_m_per_s);
23 static_assert(1_Mach * 10_percent == 33_m_per_s);
24 static_assert((0_degC + 32_degF + 491.67_degR + 273.15_K) / 4 == 273.15_K);
25 static_assert(1_A * 1_h == 3600_C);
26 static_assert(1_Ah == 3600_C);
27 }
28
30 inline void checkDatatypes() {
31 static_assert(sizeof(char) <= sizeof(short));
32 static_assert(sizeof(short) <= sizeof(int));
33 static_assert(sizeof(int) <= sizeof(long));
34 static_assert(sizeof(long) <= sizeof(long long));
35 static_assert(sizeof(float) <= sizeof(double));
36 static_assert(sizeof(double) <= sizeof(long double));
37
38 static_assert(sizeof(char) == sizeof(unsigned char));
39 static_assert(sizeof(short) == sizeof(unsigned short));
40 static_assert(sizeof(int) == sizeof(unsigned int));
41 static_assert(sizeof(long) == sizeof(unsigned long));
42
43 static_assert(sizeof(length) == sizeof(SIdouble));
44 static_assert(sizeof(mass) == sizeof(SIdouble));
45 static_assert(sizeof(time) == sizeof(SIdouble));
46 static_assert(sizeof(temperature) == sizeof(SIdouble));
47 static_assert(sizeof(electric_current) == sizeof(SIdouble));
48 static_assert(sizeof(amount_of_substance) == sizeof(SIdouble));
49 static_assert(sizeof(luminous_intensity) == sizeof(SIdouble));
50 static_assert(sizeof(dimensionless) == sizeof(SIdouble));
51 }
52
54 inline void checkBaseUnits() {
55 // length in...
56 static_assert(1_Pm == 1000_Tm);
57 static_assert(1_Tm == 1000_Gm);
58 static_assert(1_Gm == 1000_Mm);
59 static_assert(1_Mm == 1000_km);
60 static_assert(1_km == 1000_m);
61 static_assert(1_m == 10_dm);
62 static_assert(1_m == 100_cm);
63 static_assert(1_m == 1000_mm);
64 static_assert(1_m == 0.001_km);
65 static_assert(1_dm == 0.1_m);
66 static_assert(1_cm == 0.01_m);
67 static_assert(1_mm == 0.001_m);
68 static_assert(1_um == 0.001_mm);
69 static_assert(1_nm == 0.001_um);
70 // time in...
71 static_assert(1_day == 24_h);
72 static_assert(1_h == 60_min);
73 static_assert(1_min == 60_s);
74 static_assert(1_s == 1000_ms);
75 static_assert(1_ms == 0.001_s);
76 static_assert(1_us == 0.001_ms);
77 static_assert(1_ns == 0.001_us);
78 // mass in...
79 static_assert(1_Gt == 1000_Mt);
80 static_assert(1_Mt == 1000_kt);
81 static_assert(1_kt == 1000_t);
82 static_assert(1_t == 1000_kg);
83 static_assert(1_kg == 1000_g);
84 static_assert(1_g == 0.001_kg);
85 static_assert(1_mg == 0.001_g);
86 static_assert(1_ug == 0.001_mg);
87 // thermodynamic temperature in...
88 static_assert(1_GK == 1000_MK);
89 static_assert(1_MK == 1000_kK);
90 static_assert(1_kK == 1000_K);
91 static_assert(1_mK == 0.001_K);
92 static_assert(1_uK == 0.001_mK);
93 static_assert(1_nK == 0.001_uK);
94 // electric current in...
95 static_assert(1_GA == 1000_MA);
96 static_assert(1_MA == 1000_kA);
97 static_assert(1_kA == 1000_A);
98 static_assert(1_A == 1000_mA);
99 static_assert(1_mA == 0.001_A);
100 static_assert(1_uA == 0.001_mA);
101 static_assert(1_nA == 0.001_uA);
102 // amount of substance in...
103 static_assert(1_Gmol == 1000_Mmol);
104 static_assert(1_Mmol == 1000_kmol);
105 static_assert(1_kmol == 1000_mol);
106 static_assert(1_mol == 0.001_kmol);
107 static_assert(1_mmol == 0.001_mol);
108 static_assert(1_umol == 0.001_mmol);
109 static_assert(1_nmol == 0.001_umol);
110 // luminous intensity in...
111 static_assert(1_kcd == 1000_cd);
112 static_assert(1_cd == 0.001_kcd);
113 }
114
116 inline void checkDerivedUnits() {
117 // area in...
118 static_assert(1_km² == 100_hm²);
119 static_assert(1_hm² == 10000_m²);
120 static_assert(1_m² == 10000_cm²);
121 static_assert(1_cm² == 0.0001_m²);
122 static_assert(1_km² == 1_km * 1_km);
123 static_assert(1_hm² == 100_m * 100_m);
124 static_assert(1_m² == 1_m * 1_m);
125 static_assert(1_cm² == 1_cm * 1_cm);
126 static_assert(1_mm² == 1_mm * 1_mm);
127 // volume in...
128 static_assert(1_m³ == 1'000'000_cm³);
129 static_assert(1_cm³ == 0.000'001_m³);
130 static_assert(1_km³ == 1_km * 1_km * 1_km);
131 static_assert(1_m³ == 1_m * 1_m * 1_m);
132 // velocity in...
133 static_assert(1_km_per_s == 1000_m_per_s);
134 static_assert(3.6_km_per_h == 1_m_per_s);
135 static_assert(1_km_per_h == 1_km / 1_h);
136 static_assert(1_km_per_h == 1000_m / 1_h);
137 static_assert(1_km_per_h == 1_km / 60_min);
138 static_assert(1_km_per_h == 1000_m / 60_min);
139 static_assert(1_km_per_h == 1_km / 3600_s);
140 static_assert(1_km_per_h == 1000_m / 3600_s);
141 static_assert(1_km_per_h == 500_m / 1800_s);
142 // acceleration in...
143 static_assert(1_km_per_s² == 1000_m_per_s²);
144 static_assert(0.001_km_per_s² == 1_m_per_s²);
145 // frequency in...
146 static_assert(1_PHz == 1000_THz);
147 static_assert(1_THz == 1000_GHz);
148 static_assert(1_GHz == 1000_MHz);
149 static_assert(1_MHz == 1000_kHz);
150 static_assert(1_kHz == 1000_Hz);
151 static_assert(1_Hz == 0.001_kHz);
152 static_assert(1_Hz == 0.000001_MHz);
153 static_assert(1_Hz == 0.000000001_GHz);
154 static_assert(1_mHz == 0.001_Hz);
155 // radioactive activity (A) in...
156 static_assert(1_TBq == 1000_GBq);
157 static_assert(1_GBq == 1000_MBq);
158 static_assert(1_MBq == 1000_kBq);
159 static_assert(1_kBq == 1000_Bq);
160 // equivalent dose (H) and effective dose (E) in...
161 static_assert(1_Sv == 1000_mSv);
162 static_assert(1_mSv == 1000_uSv);
163 // mass per area in...
164 static_assert(1_t_per_m² == 1000_kg_per_m²);
165 // mass per volume in...
166 static_assert(1_t_per_m³ == 1000_kg_per_m³);
167 // electric potential (U) in...
168 static_assert(1_GV == 1000_MV);
169 static_assert(1_MV == 1000_kV);
170 static_assert(1_kV == 1000_V);
171 static_assert(1_V == 1000_mV);
172 static_assert(1_mV == 1000_uV);
173 // electric resistance (R) in...
174 static_assert(1_GOhm == 1000_MOhm);
175 static_assert(1_MOhm == 1000_kOhm);
176 static_assert(1_kOhm == 1000_Ohm);
177 static_assert(1_Ohm == 1000_mOhm);
178 static_assert(1_mOhm == 1000_uOhm);
179 // electric conductance (G) in...
180 static_assert(1_MS == 1000_kS);
181 static_assert(1_kS == 1000_S);
182 static_assert(1_S == 1000_mS);
183 static_assert(1_mS == 1000_uS);
184 // electric conductivity (σ) in...
185 static_assert(1_MS_per_m == 1000_kS_per_m);
186 static_assert(1_kS_per_m == 1000_S_per_m);
187 // electric charge (Q) in...
188 static_assert(1_GAh == 1000_MAh);
189 static_assert(1_MAh == 1000_kAh);
190 static_assert(1_kAh == 1000_Ah);
191 static_assert(1_Ah == 1000_mAh);
192 static_assert(1_mAh == 1000_uAh);
193 // electric capacitance (C) in...
194 static_assert(1_F == 1000_mF);
195 static_assert(1_mF == 1000_uF);
196 static_assert(1_nF == 1000_pF);
197 // electric inductance (L) in...
198 static_assert(1_H == 1000_mH);
199 static_assert(1_mH == 1000_uH);
200 // magnetic field (B) in...
201 static_assert(1_T == 1000_mT);
202 static_assert(1_mT == 1000_uT);
203 // energy (E) in...
204 static_assert(1_PJ == 1000_TJ);
205 static_assert(1_TJ == 1000_GJ);
206 static_assert(1_GJ == 1000_MJ);
207 static_assert(1_MJ == 1000_kJ);
208 static_assert(1_kJ == 1000_J);
209 static_assert(1_J == 1000_mJ);
210 // active power (P) in...
211 static_assert(1_TW == 1000_GW);
212 static_assert(1_GW == 1000_MW);
213 static_assert(1_MW == 1000_kW);
214 static_assert(1_kW == 1000_W);
215 static_assert(1_W == 1000_mW);
216 static_assert(1_mW == 1000_uW);
217 // pressure (p) in...
218 static_assert(1_MPa == 1000_kPa);
219 static_assert(1_kPa == 1000_Pa);
220 static_assert(1_Pa == 1000_mPa);
221 static_assert(1_mPa == 1000_uPa);
222 // force (F) in...
223 static_assert(1_GN == 1000_MN);
224 static_assert(1_MN == 1000_kN);
225 static_assert(1_kN == 1000_N);
226 static_assert(1_N == 1000_mN);
227 static_assert(1_mN == 1000_uN);
228 // luminous flux per area in...
229 static_assert(1_klx == 1000_lx);
230 static_assert(1_lx == 1000_mlx);
231 static_assert(1_mlx == 1000_ulx);
232 }
233
235 inline void checkAstronomicalUnits() {
236 static_assert(1_Gpc == 1000_Mpc);
237 static_assert(1_Mpc == 1000_kpc);
238 static_assert(1_kpc == 1000_pc);
239 }
240
242 inline void checkImperialUnits() {
243 static_assert(1_nmi == 10_cable);
244 static_assert(1_mi == 1760_yd);
245 static_assert(1_mi == 80_ch);
246 //static_assert(1_ft == 12_in);
247 static_assert(1_lb == 16_oz);
248 }
249
251 inline void checkDigitalUnits() {
252 // bytes absolute...
253 static_assert(1_kB == 1000_byte);
254 static_assert(1_MB == 1000_kB);
255 static_assert(1_GB == 1000_MB);
256 static_assert(1_TB == 1000_GB);
257 static_assert(1_PB == 1000_TB);
258 static_assert(1_EB == 1000_PB);
259 static_assert(1_ZB == 1000_EB);
260
261 static_assert(1_kiB == 1024_byte);
262 static_assert(1_MiB == 1024_kiB);
263 static_assert(1_GiB == 1024_MiB);
264 static_assert(1_TiB == 1024_GiB);
265 // bytes per second...
266 static_assert(1_KBps == 1000_bytes_per_s);
267 static_assert(1_MBps == 1000_KBps);
268 static_assert(1_GBps == 1000_MBps);
269 static_assert(1_TBps == 1000_GBps);
270 static_assert(1_PBps == 1000_TBps);
271
272 static_assert(1_KiBps == 1024_bytes_per_s);
273 static_assert(1_MiBps == 1024_KiBps);
274 static_assert(1_GiBps == 1024_MiBps);
275 static_assert(1_TiBps == 1024_GiBps);
276 // bits per seconds...
277 static_assert(1_Mbps == 1000_Kbps);
278 static_assert(1_Gbps == 1000_Mbps);
279 }
280
282 inline void checkVariousUnits() {
283 // pressure in...
284 static_assert(1_bar == 1000_mbar);
285 static_assert(1_kbar == 1000_bar);
286 static_assert(1_Mbar == 1000_kbar);
287 static_assert(1_Gbar == 1000_Mbar);
288 }
289
291 inline void checkFunctionsAndTemplates() {
292 static_assert(abs(-3.5_m) == 3.5_m);
293 static_assert(abs(-1_m) == 1_m);
294 static_assert(abs(0_m) == 0_m);
295 static_assert(abs(1_m) == 1_m);
296 static_assert(abs(5.6_m) == 5.6_m);
297
298 static_assert(square(-3_m) == 9_m²);
299 static_assert(square(-1_m) == 1_m²);
300 static_assert(square(-.5_m)== .25_m²);
301 static_assert(square(0_m) == 0_m²);
302 static_assert(square(.5_m) == .25_m²);
303 static_assert(square(1_m) == 1_m²);
304 static_assert(square(3_m) == 9_m²);
305
306 // static_assert(sqrt(9_m²) == 3_m); (TODO)
307
308 static_assert(cube(-3_m) == -27_m³);
309 static_assert(cube(-1_m) == -1_m³);
310 static_assert(cube(-.5_m)== -0.125_m³);
311 static_assert(cube(0_m) == 0_m³);
312 static_assert(cube(.5_m) == 0.125_m³);
313 static_assert(cube(1_m) == 1_m³);
314 static_assert(cube(3_m) == 27_m³);
315
316 // static_assert(cbrt(27_m³) == 3_m); (TODO)
317
318 static_assert(clamp(-2_m, -1_m,1_m) == -1_m);
319 static_assert(clamp(-1_m, 0_m,1_m) == 0_m);
320 static_assert(clamp(-1_m, 1_m,2_m) == 1_m);
321 static_assert(clamp(-0.5_m, 1_m,2_m) == 1_m);
322 static_assert(clamp(0_m, 0_m,1_m) == 0_m);
323 static_assert(clamp(0_m, -1_m,2_m) == 0_m);
324 static_assert(clamp(3_m, 4_m,5_m) == 4_m);
325 static_assert(clamp(3_m, 1_m,2_m) == 2_m);
326 }
327
328} // end of namespace SI
literals.h
Defines 297 literals, e.g. 24_h.
SI
Definition constants.h:12
SI::checkFeatures
void checkFeatures()
This just shows what's possible, the serious checks follow below.
Definition tests.h:13
SI::SIdouble
double SIdouble
internal datatype to hold floating point values
Definition internal.h:16
SI::checkBaseUnits
void checkBaseUnits()
Checks the SI base units.
Definition tests.h:54
SI::cube
SI_INLINE_CONSTEXPR auto cube(T x)
Raise any number <x> to power of 3 (x³ or x*x*x).
Definition units.h:196
SI::checkAstronomicalUnits
void checkAstronomicalUnits()
Checks the astronomical units.
Definition tests.h:235
SI::abs
SI_INLINE_CONSTEXPR quantity< Dimension, T > abs(const quantity< Dimension, T > &x)
Definition internal.h:563
SI::checkDigitalUnits
void checkDigitalUnits()
Checks the digital units.
Definition tests.h:251
SI::checkDatatypes
void checkDatatypes()
Checks the basic datatypes of C/C++ and libSI.
Definition tests.h:30
SI::dimensionless
double dimensionless
to hold a quantity without any unit, e.g. 42
Definition datatypes.h:18
SI::clamp
SI_INLINE_CONSTEXPR auto clamp(T x, T min, T max)
Clamp any number <x> between <min> and <max> value.
Definition units.h:200
SI::checkVariousUnits
void checkVariousUnits()
Checks various units.
Definition tests.h:282
SI::checkFunctionsAndTemplates
void checkFunctionsAndTemplates()
Checks the functions and templates.
Definition tests.h:291
SI::square
SI_INLINE_CONSTEXPR auto square(T x)
Raise any number <x> to power of 2 (x² or x*x).
Definition units.h:192
SI::checkImperialUnits
void checkImperialUnits()
Checks the Imperial units.
Definition tests.h:242
SI::checkDerivedUnits
void checkDerivedUnits()
Checks the SI derived units.
Definition tests.h:116