Loading [MathJax]/extensions/TeX/AMSsymbols.js
LAL 7.7.0.1-5e288d3
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
UnitsTest.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2014 Karl Wette (XLALification)
3* Copyright (C) 2007 Jolien Creighton, John Whelan
4*
5* This program is free software; you can redistribute it and/or modify
6* it under the terms of the GNU General Public License as published by
7* the Free Software Foundation; either version 2 of the License, or
8* (at your option) any later version.
9*
10* This program is distributed in the hope that it will be useful,
11* but WITHOUT ANY WARRANTY; without even the implied warranty of
12* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13* GNU General Public License for more details.
14*
15* You should have received a copy of the GNU General Public License
16* along with with program; see the file COPYING. If not, write to the
17* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18* MA 02110-1301 USA
19*/
20
21/**
22 * \author J. T. Whelan <john.whelan@ligo.org>
23 * \file
24 * \ingroup Units_h
25 *
26 * \brief Test Suite for unit manipulation programs
27 *
28 * ### Description ###
29 *
30 * This program tests the various units-manipulation routines, as well as
31 * the pre-defined units defined in \ref Units.h. For each
32 * successful test, it prints "PASS" to standard output.
33 *
34 * ### Uses ###
35 *
36 * \code
37 * XLALMalloc()
38 * XLALUnitAsString()
39 * XLALParseUnitString()
40 * XLALFree()
41 * XLALUnitMultiply()
42 * XLALUnitRaiseRAT4()
43 * XLALUnitNormalize()
44 * XLALUnitCompare()
45 * \endcode
46 *
47 */
48
49/** \cond DONT_DOXYGEN */
50
51#include <config.h>
52#include <stdlib.h>
53#include <lal/LALStdlib.h>
54#include <lal/Units.h>
55#include <lal/AVFactories.h>
56
57int main(void) {
58
59 int errnum;
60 LALUnit unit1, unit2, unit3, *punit;
61 RAT4 power;
62 CHAR *string, buffer[LALUnitTextSize];
63 UINT4 length;
64
65 printf("Checking input validation of XLALUnitAsString:\n");
66
67 length = sizeof("m^2 kg s^-3 A^-1") - 1;
68 string = XLALMalloc(length);
69 XLAL_CHECK( string != NULL, XLAL_EFAILED );
70
71 XLAL_TRY( XLALUnitAsString( NULL, length, &unit1 ), errnum );
72 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
73 printf(" PASS: Null pointer to output string\n");
74
75 XLAL_TRY( XLALUnitAsString( string, 0, &unit1 ), errnum );
76 XLAL_CHECK( errnum == XLAL_EBADLEN, XLAL_EFAILED );
77 printf(" PASS: Bad output string length\n");
78
79 XLAL_TRY( XLALUnitAsString( string, length, NULL ), errnum );
80 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
81 printf(" PASS: Null pointer to input LALUnit\n");
82
83 XLAL_TRY( XLALUnitAsString( string, length, &lalVoltUnit ), errnum );
84 XLAL_CHECK( errnum == XLAL_EBADLEN, XLAL_EFAILED );
85 printf(" PASS: Output string too short\n");
86
87 XLALFree(string);
88
89 printf("Testing response of XLALUnitAsString to valid data:\n");
90
91 length = sizeof("m^2 kg s^-3 A^-1");
92 string = XLALMalloc(length);
93 XLAL_CHECK( string != NULL, XLAL_EFAILED );
94
95 XLAL_CHECK( XLALUnitAsString( string, length, &lalVoltUnit ) != NULL, XLAL_EFAILED );
96 XLAL_CHECK( strcmp(string, "m^2 kg s^-3 A^-1") == 0, XLAL_EFAILED );
97 printf(" PASS: String representation of Volt is '%s'\n", string);
98
99 XLALFree(string);
100
101 length = sizeof("10^-12 m^-2 kg^-1 s^2 A^2");
102 string = XLALMalloc(length);
103 XLAL_CHECK( string != NULL, XLAL_EFAILED );
104
105 XLAL_CHECK( XLALUnitAsString( string, length, &lalPicoFaradUnit ) != NULL, XLAL_EFAILED );
106 XLAL_CHECK( strcmp(string, "10^-12 m^-2 kg^-1 s^2 A^2") == 0, XLAL_EFAILED );
107 printf(" PASS: String representation of PicoFarad is '%s'\n", string);
108
109 XLAL_CHECK( XLALUnitAsString( string, length, &lalMeterUnit ) != NULL, XLAL_EFAILED );
110 XLAL_CHECK( strcmp(string, "m") == 0, XLAL_EFAILED );
111 printf(" PASS: String representation of Meter is '%s'\n", string);
112
113 XLAL_CHECK( XLALUnitAsString( string, length, &lalCoulombUnit ) != NULL, XLAL_EFAILED );
114 XLAL_CHECK( strcmp(string, "s A") == 0, XLAL_EFAILED );
115 printf(" PASS: String representation of Coulomb is '%s'\n", string);
116
117 XLAL_CHECK( XLALUnitAsString( string, length, &lalMegaUnit ) != NULL, XLAL_EFAILED );
118 XLAL_CHECK( strcmp(string, "10^6") == 0, XLAL_EFAILED );
119 printf(" PASS: String representation of Mega is '%s'\n", string);
120
121 XLAL_CHECK( XLALUnitAsString( string, length, &lalAttoStrainUnit ) != NULL, XLAL_EFAILED );
122 XLAL_CHECK( strcmp(string, "10^-18 strain") == 0, XLAL_EFAILED );
123 printf(" PASS: String representation of AttoStrain is '%s'\n", string);
124
125 XLAL_CHECK( XLALUnitAsString( string, length, &lalDimensionlessUnit ) != NULL, XLAL_EFAILED );
126 XLAL_CHECK( strcmp(string, "") == 0, XLAL_EFAILED );
127 printf(" PASS: String representation of dimensionless is '%s'\n", string);
128
129 XLALFree(string);
130
131 printf("Checking input validation of XLALParseUnitString:\n");
132
133 punit = XLALParseUnitString( NULL, "" );
134 XLAL_CHECK( punit != NULL, XLAL_EFAILED );
135 XLAL_CHECK( XLALUnitCompare( punit, &lalDimensionlessUnit) == 0, XLAL_EFAILED );
136 XLALFree(punit);
137 printf(" PASS: Null pointer to output LALUnit allocates new one\n");
138
139 punit = XLALParseUnitString( &unit1, NULL );
140 XLAL_CHECK( punit == &unit1, XLAL_EFAILED );
141 XLAL_CHECK( XLALUnitCompare( &unit1, &lalDimensionlessUnit) == 0, XLAL_EFAILED );
142 printf(" PASS: Null pointer to string returns dimensionless\n");
143
144 memset(buffer, 0, LALUnitTextSize);
145
146 strncpy( buffer, "10^", LALUnitTextSize );
147 XLAL_TRY( XLALParseUnitString( &unit1, buffer ), errnum );
148 XLAL_CHECK( errnum == XLAL_EFAILED, XLAL_EFAILED );
149 printf(" PASS: Expected failure to parse '%s'\n", buffer);
150
151 strncpy( buffer, "s^3 s^2", LALUnitTextSize );
152 XLAL_TRY( XLALParseUnitString( &unit1, buffer ), errnum );
153 XLAL_CHECK( errnum == XLAL_EFAILED, XLAL_EFAILED );
154 printf(" PASS: Expected failure to parse '%s'\n", buffer);
155
156 strncpy( buffer, "V", LALUnitTextSize );
157 XLAL_TRY( XLALParseUnitString( &unit1, buffer ), errnum );
158 XLAL_CHECK( errnum == XLAL_EFAILED, XLAL_EFAILED );
159 printf(" PASS: Expected failure to parse '%s'\n", buffer);
160
161 printf("Testing response of XLALParseUnitString to valid data:\n");
162
163 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalVoltUnit ) != NULL, XLAL_EFAILED );
164 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
165 XLAL_CHECK( XLALUnitCompare( &unit1, &lalVoltUnit ) == 0, XLAL_EFAILED );
166 printf(" PASS: Volt <-> string\n");
167
168 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalPicoFaradUnit ) != NULL, XLAL_EFAILED );
169 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
170 XLAL_CHECK( XLALUnitCompare( &unit1, &lalPicoFaradUnit ) == 0, XLAL_EFAILED );
171 printf(" PASS: PicoFarad <-> string\n");
172
173 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalMeterUnit ) != NULL, XLAL_EFAILED );
174 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
175 XLAL_CHECK( XLALUnitCompare( &unit1, &lalMeterUnit ) == 0, XLAL_EFAILED );
176 printf(" PASS: Meter <-> string\n");
177
178 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalAttoStrainUnit ) != NULL, XLAL_EFAILED );
179 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
180 XLAL_CHECK( XLALUnitCompare( &unit1, &lalAttoStrainUnit ) == 0, XLAL_EFAILED );
181 printf(" PASS: AttoStrain <-> string\n");
182
183 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalCoulombUnit ) != NULL, XLAL_EFAILED );
184 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
185 XLAL_CHECK( XLALUnitCompare( &unit1, &lalCoulombUnit ) == 0, XLAL_EFAILED );
186 printf(" PASS: Coulomb <-> string\n");
187
188 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalMegaUnit ) != NULL, XLAL_EFAILED );
189 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
190 XLAL_CHECK( XLALUnitCompare( &unit1, &lalMegaUnit ) == 0, XLAL_EFAILED );
191 printf(" PASS: Mega <-> string\n");
192
193 XLAL_CHECK( XLALUnitAsString( buffer, LALUnitTextSize, &lalDimensionlessUnit ) != NULL, XLAL_EFAILED );
194 XLAL_CHECK( XLALParseUnitString( &unit1, buffer ) != NULL, XLAL_EFAILED );
195 XLAL_CHECK( XLALUnitCompare( &unit1, &lalDimensionlessUnit ) == 0, XLAL_EFAILED );
196 printf(" PASS: Dimensionless <-> string\n");
197
198 unit1 = unit2 = lalDimensionlessUnit;
199
200 printf("Checking input validation of LALUnitMultiply:\n");
201
202 XLAL_TRY( XLALUnitMultiply( NULL, &unit1, &unit2 ), errnum );
203 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
204 printf(" PASS: Null pointer to output LALUnit\n");
205
206 XLAL_TRY( XLALUnitMultiply( &unit3, NULL, NULL ), errnum );
207 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
208 printf(" PASS: Null pointer to input LALUnits\n");
209
210 unit1.powerOfTen = 20000;
211 unit2.powerOfTen = 30000;
212 XLAL_TRY( XLALUnitMultiply( &unit3, &unit1, &unit2 ), errnum );
213 XLAL_CHECK( errnum == XLAL_ERANGE, XLAL_EFAILED );
214 printf(" PASS: Exponent outside of (U)INT2 bounds\n");
215
216 unit1.powerOfTen = 0;
217 unit2.powerOfTen = 0;
218 unit1.unitNumerator[2] = 12345;
219 unit1.unitDenominatorMinusOne[2] = 23456;
220 unit2.unitNumerator[2] = 23456;
221 unit2.unitDenominatorMinusOne[2] = 12345;
222 XLAL_TRY( XLALUnitMultiply( &unit3, &unit1, &unit2 ), errnum );
223 XLAL_CHECK( errnum == XLAL_ERANGE, XLAL_EFAILED );
224 printf(" PASS: Product outside of (U)INT2 bounds\n");
225
226 printf("Checking input validation of XLALUnitRaiseRAT4:\n");
227
228 XLAL_TRY( XLALUnitRaiseRAT4( NULL, &unit1, &power ), errnum );
229 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
230 printf(" PASS: Null pointer to output LALUnit\n");
231
232 XLAL_TRY( XLALUnitRaiseRAT4( &unit3, NULL, &power ), errnum );
233 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
234 printf(" PASS: Null pointer to input LALUnit\n");
235
236 XLAL_TRY( XLALUnitRaiseRAT4( &unit3, &unit1, NULL ), errnum );
237 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
238 printf(" PASS: Null pointer to input RAT4\n");
239
240 unit1 = lalKiloUnit;
241 power.numerator = 1;
242 power.denominatorMinusOne = 1;
243 XLAL_TRY( XLALUnitRaiseRAT4( &unit2, &unit1, &power ), errnum );
244 XLAL_CHECK( errnum == XLAL_EINVAL, XLAL_EFAILED );
245 printf(" PASS: Non-integer power of ten\n");
246
247 unit1.unitNumerator[2] = 20000;
248 unit1.unitNumerator[2] += 20000;
249 power.numerator = 2;
250 power.denominatorMinusOne = 0;
251 XLAL_TRY( XLALUnitRaiseRAT4( &unit2, &unit1, &power ), errnum );
252 XLAL_CHECK( errnum == XLAL_ERANGE, XLAL_EFAILED );
253 printf(" PASS: Exponent outside of (U)INT2 bounds\n");
254
255 printf("Testing response of XLALUnitNormalize to valid data:\n");
256
257 unit1 = lalDimensionlessUnit;
258 unit1.unitNumerator[0] = 2;
259 unit1.unitDenominatorMinusOne[0] = 5;
260 XLAL_CHECK( XLALUnitNormalize( &unit1 ) == XLAL_SUCCESS, XLAL_EFAILED );
261 unit2 = lalDimensionlessUnit;
262 unit2.unitNumerator[0] = 1;
263 unit2.unitDenominatorMinusOne[0] = 2;
264 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
265 printf(" PASS: 2/6 reduces to 1/3\n");
266
267 printf("Checking input validation of XLALUnitCompare:\n");
268
269 XLAL_TRY( XLALUnitCompare( &unit1, NULL ), errnum );
270 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
271 XLAL_TRY( XLALUnitCompare( NULL, &unit2 ), errnum );
272 XLAL_CHECK( errnum == XLAL_EFAULT, XLAL_EFAILED );
273 printf(" PASS: Null pointer to input LALUnits\n");
274
275 printf("Testing response of XLALUnitCompare to valid data:\n");
276
277 XLAL_CHECK( XLALUnitCompare( &lalMeterUnit, &lalMeterUnit ) == 0, XLAL_EFAILED );
278 printf(" PASS: m = m\n");
279
280 XLAL_CHECK( XLALUnitCompare( &lalMeterUnit, &lalKiloGramUnit ) != 0, XLAL_EFAILED );
281 printf(" PASS: m != kg\n");
282
283 XLAL_CHECK( XLALUnitCompare( &lalGramUnit, &lalKiloGramUnit ) != 0, XLAL_EFAILED );
284 printf(" PASS: g != kg\n");
285
286 printf("Testing definitions of basic units:\n");
287
288 unit1 = lalDimensionlessUnit;
289 unit1.unitNumerator[LALUnitIndexMeter] = 1;
290 unit2 = lalMeterUnit;
291 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
292 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexMeter] == 1, XLAL_EFAILED );
293 printf(" PASS: meter\n");
294
295 unit1 = lalDimensionlessUnit;
296 unit1.unitNumerator[LALUnitIndexKiloGram] = 1;
297 unit2 = lalKiloGramUnit;
298 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
299 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexKiloGram] == 1, XLAL_EFAILED );
300 printf(" PASS: kilogram\n");
301
302 unit1 = lalDimensionlessUnit;
303 unit1.unitNumerator[LALUnitIndexSecond] = 1;
304 unit2 = lalSecondUnit;
305 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
306 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexSecond] == 1, XLAL_EFAILED );
307 printf(" PASS: second\n");
308
309 unit1 = lalDimensionlessUnit;
310 unit1.unitNumerator[LALUnitIndexAmpere] = 1;
311 unit2 = lalAmpereUnit;
312 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
313 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexAmpere] == 1, XLAL_EFAILED );
314 printf(" PASS: Ampere\n");
315
316 unit1 = lalDimensionlessUnit;
317 unit1.unitNumerator[LALUnitIndexKelvin] = 1;
318 unit2 = lalKelvinUnit;
319 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
320 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexKelvin] == 1, XLAL_EFAILED );
321 printf(" PASS: Kelvin\n");
322
323 unit1 = lalDimensionlessUnit;
324 unit1.unitNumerator[LALUnitIndexStrain] = 1;
325 unit2 = lalStrainUnit;
326 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
327 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexStrain] == 1, XLAL_EFAILED );
328 printf(" PASS: strain\n");
329
330 unit1 = lalDimensionlessUnit;
331 unit1.unitNumerator[LALUnitIndexADCCount] = 1;
332 unit2 = lalADCCountUnit;
333 XLAL_CHECK( XLALUnitCompare( &unit1, &unit2 ) == 0, XLAL_EFAILED );
334 XLAL_CHECK( unit2.unitNumerator[LALUnitIndexADCCount] == 1, XLAL_EFAILED );
335 printf(" PASS: ADC Count\n");
336
337 printf("Testing definitions of derived units:\n");
338
339 power.numerator = -1;
340 power.denominatorMinusOne = 0;
341 XLAL_CHECK( XLALUnitRaiseRAT4( &unit1, &lalSecondUnit, &power ) != NULL, XLAL_EFAILED );
342 XLAL_CHECK( XLALUnitCompare( &unit1, &lalHertzUnit ) == 0, XLAL_EFAILED );
343 printf(" PASS: Hz is s^-1\n");
344
345 power.numerator = -2;
346 power.denominatorMinusOne = 0;
347 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalSecondUnit, &power ) != NULL, XLAL_EFAILED );
348 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalMeterUnit, &unit2 ) != NULL, XLAL_EFAILED );
349 XLAL_CHECK( XLALUnitMultiply( &unit2, &lalKiloGramUnit, &unit1 ) != NULL, XLAL_EFAILED );
350 XLAL_CHECK( XLALUnitCompare( &unit2, &lalNewtonUnit ) == 0, XLAL_EFAILED );
351 printf(" PASS: N is kg m s^-2\n");
352
353 power.numerator = -2;
354 power.denominatorMinusOne = 0;
355 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalMeterUnit, &power ) != NULL, XLAL_EFAILED );
356 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalNewtonUnit, &unit2 ) != NULL, XLAL_EFAILED );
357 XLAL_CHECK( XLALUnitCompare( &unit1, &lalPascalUnit ) == 0, XLAL_EFAILED );
358 printf(" PASS: Pa is N m^-2\n");
359
360 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalNewtonUnit, &lalMeterUnit ) != NULL, XLAL_EFAILED );
361 XLAL_CHECK( XLALUnitCompare( &unit1, &lalJouleUnit ) == 0, XLAL_EFAILED );
362 printf(" PASS: J is N m\n");
363
364 power.numerator = -1;
365 power.denominatorMinusOne = 0;
366 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalSecondUnit, &power ) != NULL, XLAL_EFAILED );
367 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalJouleUnit, &unit2 ) != NULL, XLAL_EFAILED );
368 XLAL_CHECK( XLALUnitCompare( &unit1, &lalWattUnit ) == 0, XLAL_EFAILED );
369 printf(" PASS: W is J/s\n");
370
371 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalAmpereUnit, &lalSecondUnit ) != NULL, XLAL_EFAILED );
372 XLAL_CHECK( XLALUnitCompare( &unit1, &lalCoulombUnit ) == 0, XLAL_EFAILED );
373 printf(" PASS: C is A s\n");
374
375 power.numerator = -1;
376 power.denominatorMinusOne = 0;
377 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalAmpereUnit, &power ) != NULL, XLAL_EFAILED );
378 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalWattUnit, &unit2 ) != NULL, XLAL_EFAILED );
379 XLAL_CHECK( XLALUnitCompare( &unit1, &lalVoltUnit ) == 0, XLAL_EFAILED );
380 printf(" PASS: V is W/A\n");
381
382 power.numerator = -1;
383 power.denominatorMinusOne = 0;
384 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalAmpereUnit, &power ) != NULL, XLAL_EFAILED );
385 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalVoltUnit, &unit2 ) != NULL, XLAL_EFAILED );
386 XLAL_CHECK( XLALUnitCompare( &unit1, &lalOhmUnit ) == 0, XLAL_EFAILED );
387 printf(" PASS: Ohm is V/A\n");
388
389 power.numerator = -1;
390 power.denominatorMinusOne = 0;
391 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalVoltUnit, &power ) != NULL, XLAL_EFAILED );
392 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalCoulombUnit, &unit2 ) != NULL, XLAL_EFAILED );
393 XLAL_CHECK( XLALUnitCompare( &unit1, &lalFaradUnit ) == 0, XLAL_EFAILED );
394 printf(" PASS: F is C/V\n");
395
396 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalVoltUnit, &lalSecondUnit ) != NULL, XLAL_EFAILED );
397 XLAL_CHECK( XLALUnitCompare( &unit1, &lalWeberUnit ) == 0, XLAL_EFAILED );
398 printf(" PASS: Wb is V s\n");
399
400 power.numerator = -1;
401 power.denominatorMinusOne = 0;
402 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalAmpereUnit, &power ) != NULL, XLAL_EFAILED );
403 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalSecondUnit, &unit2 ) != NULL, XLAL_EFAILED );
404 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalVoltUnit, &unit1 ) != NULL, XLAL_EFAILED );
405 XLAL_CHECK( XLALUnitCompare( &unit1, &lalHenryUnit ) == 0, XLAL_EFAILED );
406 printf(" PASS: H is V s/A\n");
407
408 power.numerator = -2;
409 power.denominatorMinusOne = 0;
410 XLAL_CHECK( XLALUnitRaiseRAT4( &unit2, &lalMeterUnit, &power ) != NULL, XLAL_EFAILED );
411 XLAL_CHECK( XLALUnitMultiply( &unit1, &lalWeberUnit, &unit2 ) != NULL, XLAL_EFAILED );
412 XLAL_CHECK( XLALUnitCompare( &unit1, &lalTeslaUnit ) == 0, XLAL_EFAILED );
413 printf(" PASS: T is Wb m^-2\n");
414
415 LALCheckMemoryLeaks();
416
417 printf("PASS: All tests\n");
418
419 return 0;
420
421}
422
423/** \endcond */
LALCheckMemoryLeaks
void LALCheckMemoryLeaks(void)
Definition: LALMalloc.c:784
main
int main(int argc, char *argv[])
Definition: cache.c:25
CHAR
char CHAR
One-byte signed integer, see Headers LAL(Atomic)Datatypes.h for more details.
Definition: LALAtomicDatatypes.h:37
UINT4
uint32_t UINT4
Four-byte unsigned integer.
Definition: LALAtomicDatatypes.h:59
LALUnitIndexKelvin
@ LALUnitIndexKelvin
The kelvin index.
Definition: LALDatatypes.h:477
LALUnitIndexMeter
@ LALUnitIndexMeter
The meter index.
Definition: LALDatatypes.h:473
LALUnitIndexKiloGram
@ LALUnitIndexKiloGram
The kilogram index.
Definition: LALDatatypes.h:474
LALUnitIndexSecond
@ LALUnitIndexSecond
The second index.
Definition: LALDatatypes.h:475
LALUnitIndexADCCount
@ LALUnitIndexADCCount
The ADC counts index.
Definition: LALDatatypes.h:479
LALUnitIndexStrain
@ LALUnitIndexStrain
The strain index.
Definition: LALDatatypes.h:478
LALUnitIndexAmpere
@ LALUnitIndexAmpere
The ampere index.
Definition: LALDatatypes.h:476
XLALMalloc
#define XLALMalloc(n)
Definition: LALMalloc.h:44
XLALFree
#define XLALFree(p)
Definition: LALMalloc.h:47
XLALUnitCompare
int XLALUnitCompare(const LALUnit *unit1, const LALUnit *unit2)
Returns 0 if the the normal form of the two unit structures are the same or > 0 if they are different...
Definition: UnitCompare.c:90
LALUnitTextSize
@ LALUnitTextSize
Definition: Units.h:174
lalWattUnit
const LALUnit lalWattUnit
Watt [W ].
Definition: UnitDefs.c:175
lalKelvinUnit
const LALUnit lalKelvinUnit
Kelvin [K].
Definition: UnitDefs.c:164
lalHenryUnit
const LALUnit lalHenryUnit
Henry [H].
Definition: UnitDefs.c:185
lalStrainUnit
const LALUnit lalStrainUnit
Strain [1].
Definition: UnitDefs.c:165
lalWeberUnit
const LALUnit lalWeberUnit
Weber [Wb].
Definition: UnitDefs.c:184
XLALParseUnitString
LALUnit * XLALParseUnitString(LALUnit *output, const char *string)
Returns the pointer output upon return or a pointer to newly allocated memory if output was NULL; on ...
Definition: UnitDefs.c:354
lalKiloGramUnit
const LALUnit lalKiloGramUnit
kilogram [kg]
Definition: UnitDefs.c:161
lalNewtonUnit
const LALUnit lalNewtonUnit
Newton [N].
Definition: UnitDefs.c:172
lalAmpereUnit
const LALUnit lalAmpereUnit
Ampere [A].
Definition: UnitDefs.c:163
XLALUnitAsString
char * XLALUnitAsString(char *string, UINT4 length, const LALUnit *input)
Returns the pointer to the input string, which is populated with the unit string if successful.
Definition: UnitDefs.c:276
lalAttoStrainUnit
const LALUnit lalAttoStrainUnit
AttoStrain [1e-18].
Definition: UnitDefs.c:216
lalCoulombUnit
const LALUnit lalCoulombUnit
Coulomb [C].
Definition: UnitDefs.c:180
lalTeslaUnit
const LALUnit lalTeslaUnit
Tesla [T].
Definition: UnitDefs.c:186
lalSecondUnit
const LALUnit lalSecondUnit
second [s]
Definition: UnitDefs.c:162
lalGramUnit
const LALUnit lalGramUnit
Gram [1e-3].
Definition: UnitDefs.c:215
lalJouleUnit
const LALUnit lalJouleUnit
Joule [J].
Definition: UnitDefs.c:174
lalADCCountUnit
const LALUnit lalADCCountUnit
ADC count [count].
Definition: UnitDefs.c:166
lalHertzUnit
const LALUnit lalHertzUnit
Hertz [Hz].
Definition: UnitDefs.c:171
lalMeterUnit
const LALUnit lalMeterUnit
meter [m]
Definition: UnitDefs.c:160
lalPicoFaradUnit
const LALUnit lalPicoFaradUnit
PicoFarad [1e-12 F].
Definition: UnitDefs.c:217
lalDimensionlessUnit
const LALUnit lalDimensionlessUnit
dimensionless units
Definition: UnitDefs.c:156
lalOhmUnit
const LALUnit lalOhmUnit
Ohm [ ].
Definition: UnitDefs.c:182
lalKiloUnit
const LALUnit lalKiloUnit
Kilo [1e3].
Definition: UnitDefs.c:198
lalVoltUnit
const LALUnit lalVoltUnit
Volt [V].
Definition: UnitDefs.c:181
lalPascalUnit
const LALUnit lalPascalUnit
Pascal [Pa].
Definition: UnitDefs.c:173
lalMegaUnit
const LALUnit lalMegaUnit
Mega [1e6].
Definition: UnitDefs.c:197
lalFaradUnit
const LALUnit lalFaradUnit
Farad [F].
Definition: UnitDefs.c:183
XLALUnitMultiply
LALUnit * XLALUnitMultiply(LALUnit *output, const LALUnit *unit1, const LALUnit *unit2)
This function multiplies together the LALUnit structures *(input->unitOne) and *(input->unitTwo),...
Definition: UnitMultiply.c:64
XLALUnitNormalize
int XLALUnitNormalize(LALUnit *unit)
Returns 0 upon success or XLAL_FAILURE if the input pointer is NULL, in which case xlalErrno is set t...
Definition: UnitNormalize.c:72
XLALUnitRaiseRAT4
LALUnit * XLALUnitRaiseRAT4(LALUnit *output, const LALUnit *input, const RAT4 *power)
Raises a LALUnit structure to a rational power given by the RAT4 structure power.
Definition: UnitRaise.c:56
XLAL_CHECK
#define XLAL_CHECK(assertion,...)
Macro to test an assertion and invoke a failure if it is not true in a function that returns an integ...
Definition: XLALError.h:810
XLAL_TRY
#define XLAL_TRY(statement, errnum)
A macro to (i) disable the XLAL error handling and preserve the current value of xlalErrno (ii) perfo...
Definition: XLALError.h:582
XLAL_EBADLEN
@ XLAL_EBADLEN
Inconsistent or invalid length.
Definition: XLALError.h:419
XLAL_SUCCESS
@ XLAL_SUCCESS
Success return value (not an error number)
Definition: XLALError.h:401
XLAL_EFAULT
@ XLAL_EFAULT
Invalid pointer.
Definition: XLALError.h:408
XLAL_ERANGE
@ XLAL_ERANGE
Output range error.
Definition: XLALError.h:411
XLAL_EINVAL
@ XLAL_EINVAL
Invalid argument.
Definition: XLALError.h:409
XLAL_EFAILED
@ XLAL_EFAILED
Generic failure.
Definition: XLALError.h:418
LALUnit
This structure stores units in the mksA system (plus Kelvin, Strain, and ADC Count).
Definition: LALDatatypes.h:498
LALUnit::powerOfTen
INT2 powerOfTen
Overall power-of-ten scaling is 10^powerOfTen.
Definition: LALDatatypes.h:499
LALUnit::unitDenominatorMinusOne
UINT2 unitDenominatorMinusOne[LALNumUnits]
Array of unit power denominators-minus-one.
Definition: LALDatatypes.h:501
LALUnit::unitNumerator
INT2 unitNumerator[LALNumUnits]
Array of unit power numerators.
Definition: LALDatatypes.h:500
RAT4
A four-byte rational number, used as a parameter structure for XLALUnitRaiseRAT4().
Definition: Units.h:144
RAT4::numerator
INT2 numerator
The numerator.
Definition: Units.h:145
RAT4::denominatorMinusOne
UINT2 denominatorMinusOne
One less than the denominator.
Definition: Units.h:146