LAL  7.5.0.1-89842e6
VectorMathTest.c
Go to the documentation of this file.
1 /*
2 * Copyright (C) 2015 Reinhard Prix, Karl Wette
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with with program; see the file COPYING. If not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17 * MA 02110-1301 USA
18 */
19 #include <math.h>
20 #include <stdlib.h>
21 
22 #include <config.h>
23 
24 #include <lal/LALVCSInfo.h>
25 #include <lal/LALConstants.h>
26 #include <lal/XLALError.h>
27 #include <lal/AVFactories.h>
28 #include <lal/LogPrintf.h> // for timing function XLALGetCPUTime()
29 #include <lal/UserInput.h>
30 
31 #include <lal/VectorMath.h>
32 
33 /* for access to internal prototypes for generic (GEN) functions, for reference results */
34 #include <vectorops/VectorMath_internal.h>
35 
36 // ---------- Macros ----------
37 #define frand() (rand() / (REAL4)RAND_MAX)
38 #define Relerr(dx,x) (fabsf(x)>0 ? fabsf((dx)/(x)) : fabsf(dx) )
39 #define Relerrd(dx,x) (fabs(x)>0 ? fabs((dx)/(x)) : fabs(dx) )
40 #define cRelerr(dx,x) (cabsf(x)>0 ? cabsf((dx)/(x)) : fabsf(dx) )
41 
42 // ----- test and benchmark operators with 1 REAL4 vector input and 1 INT4 vector output (S2I) ----------
43 #define TESTBENCH_VECTORMATH_S2I(name,in) \
44  { \
45  XLAL_CHECK ( XLALVector##name##REAL4_GEN( xOutRefI4->data, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
46  tic = XLALGetCPUTime(); \
47  for (UINT4 l=0; l < Nruns; l ++ ) { \
48  XLAL_CHECK ( XLALVector##name##REAL4( xOutI4->data, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
49  } \
50  toc = XLALGetCPUTime(); \
51  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
52  { \
53  XLAL_CHECK ( xOutI4->data[i] == xOutRefI4->data[i], XLAL_ETOL, "%s: found element #%u (%i) differs from reference (%i)", #name, i, xOutI4->data[i], xOutRefI4->data[i] ); \
54  } \
55  XLALPrintInfo ( "%-32s: %4.0f Mops/sec\n", XLALVector##name##REAL4_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6 ); \
56  }
57 
58 // ----- test and benchmark operators with 1 REAL4 vector input and 1 REAL4 vector output (S2S) ----------
59 #define TESTBENCH_VECTORMATH_S2S(name,in) \
60  { \
61  XLAL_CHECK ( XLALVector##name##REAL4_GEN( xOutRef, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
62  tic = XLALGetCPUTime(); \
63  for (UINT4 l=0; l < Nruns; l ++ ) { \
64  XLAL_CHECK ( XLALVector##name##REAL4( xOut, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
65  } \
66  toc = XLALGetCPUTime(); \
67  maxErr = maxRelerr = 0; \
68  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
69  { \
70  REAL4 err = fabsf ( xOut[i] - xOutRef[i] ); \
71  REAL4 relerr = Relerr ( err, xOutRef[i] ); \
72  maxErr = fmaxf ( err, maxErr ); \
73  maxRelerr = fmaxf ( relerr, maxRelerr ); \
74  } \
75  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
76  XLALVector##name##REAL4_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, (reltol) ); \
77  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxErr, abstol ); \
78  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxRelerr, reltol ); \
79  }
80 
81 #define TESTBENCH_VECTORMATH_S2SS(name,in) \
82  { \
83  XLAL_CHECK ( XLALVector##name##REAL4_GEN( xOutRef, xOutRef2, xIn, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
84  tic = XLALGetCPUTime(); \
85  for (UINT4 l=0; l < Nruns; l ++ ) { \
86  XLAL_CHECK ( XLALVector##name##REAL4( xOut, xOut2, xIn, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
87  } \
88  toc = XLALGetCPUTime(); \
89  maxErr = maxRelerr = 0; \
90  for ( UINT4 i = 0; i < Ntrials; i ++ ) { \
91  REAL4 err1 = fabsf ( xOut[i] - xOutRef[i] ); \
92  REAL4 err2 = fabsf ( xOut2[i] - xOutRef2[i] ); \
93  REAL4 relerr1 = Relerr ( err1, xOutRef[i] ); \
94  REAL4 relerr2 = Relerr ( err2, xOutRef2[i] ); \
95  maxErr = fmaxf ( err1, maxErr ); \
96  maxErr = fmaxf ( err2, maxErr ); \
97  maxRelerr = fmaxf ( relerr1, maxRelerr ); \
98  maxRelerr = fmaxf ( relerr2, maxRelerr ); \
99  } \
100  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
101  XLALVector##name##REAL4_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, reltol ); \
102  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxErr, abstol ); \
103  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxRelerr, reltol ); \
104  }
105 
106 
107 #define TESTBENCH_VECTORMATH_SS2S(name,in1,in2) \
108  { \
109  XLAL_CHECK ( XLALVector##name##REAL4_GEN( xOutRef, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
110  tic = XLALGetCPUTime(); \
111  for (UINT4 l=0; l < Nruns; l ++ ) { \
112  XLAL_CHECK ( XLALVector##name##REAL4( xOut, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
113  } \
114  toc = XLALGetCPUTime(); \
115  maxErr = maxRelerr = 0; \
116  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
117  { \
118  REAL4 err = fabsf ( xOut[i] - xOutRef[i] ); \
119  REAL4 relerr = Relerr ( err, xOutRef[i] ); \
120  maxErr = fmaxf ( err, maxErr ); \
121  maxRelerr = fmaxf ( relerr, maxRelerr ); \
122  } \
123  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
124  XLALVector##name##REAL4_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, (reltol) ); \
125  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxErr, abstol ); \
126  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "REAL4", maxRelerr, reltol ); \
127  }
128 
129 
130 #define TESTBENCH_VECTORMATH_SS2uU(name,in1,in2) \
131  { \
132  UINT4 xCount = 0, xCountRef = 0; \
133  XLAL_CHECK ( XLALVector##name##REAL4_GEN( &xCountRef, xOutRefU4->data, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
134  tic = XLALGetCPUTime(); \
135  for (UINT4 l=0; l < Nruns; l ++ ) { \
136  XLAL_CHECK ( XLALVector##name##REAL4( &xCount, xOutU4->data, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
137  XLAL_CHECK ( xCount == xCountRef, XLAL_ETOL, "%s: count of found elements (%u) differs from reference (%u)", #name, xCount, xCountRef ); \
138  } \
139  toc = XLALGetCPUTime(); \
140  for ( UINT4 i = 0; i < xCount; i ++ ) \
141  { \
142  XLAL_CHECK ( xOutU4->data[i] == xOutRefU4->data[i], XLAL_ETOL, "%s: found element #%u (%u) differs from reference (%u)", #name, i, xOutU4->data[i], xOutRefU4->data[i] ); \
143  } \
144  XLALPrintInfo ( "%-32s: %4.0f Mops/sec\n", XLALVector##name##REAL4_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6 ); \
145  }
146 
147 #define TESTBENCH_VECTORMATH_DD2D(name,in1,in2) \
148  { \
149  XLAL_CHECK ( XLALVector##name##REAL8_GEN( xOutRefD, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
150  tic = XLALGetCPUTime(); \
151  for (UINT4 l=0; l < Nruns; l ++ ) { \
152  XLAL_CHECK ( XLALVector##name##REAL8( xOutD, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
153  } \
154  toc = XLALGetCPUTime(); \
155  maxErr = maxRelerr = 0; \
156  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
157  { \
158  REAL8 err = fabs ( xOutD[i] - xOutRefD[i] ); \
159  REAL8 relerr = Relerrd ( err, xOutRefD[i] ); \
160  maxErr = fmax ( err, maxErr ); \
161  maxRelerr = fmax ( relerr, maxRelerr ); \
162  } \
163  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
164  XLALVector##name##REAL8_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, (reltol) ); \
165  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "REAL8", maxErr, abstol ); \
166  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "REAL8", maxRelerr, reltol ); \
167  }
168 
169 #define TESTBENCH_VECTORMATH_CC2C(name,in1,in2) \
170  { \
171  XLAL_CHECK ( XLALVector##name##COMPLEX8_GEN( xOutRefC, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
172  tic = XLALGetCPUTime(); \
173  for (UINT4 l=0; l < Nruns; l ++ ) { \
174  XLAL_CHECK ( XLALVector##name##COMPLEX8( xOutC, in1, in2, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
175  } \
176  toc = XLALGetCPUTime(); \
177  maxErr = maxRelerr = 0; \
178  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
179  { \
180  REAL4 err = cabsf ( xOutC[i] - xOutRefC[i] ); \
181  REAL4 relerr = cRelerr ( err, xOutRefC[i] ); \
182  maxErr = fmaxf ( err, maxErr ); \
183  maxRelerr = fmaxf ( relerr, maxRelerr ); \
184  } \
185  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
186  XLALVector##name##COMPLEX8_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, (reltol) ); \
187  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "COMPLEX8", maxErr, abstol ); \
188  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "COMPLEX8", maxRelerr, reltol ); \
189  }
190 
191 // ----- test and benchmark operators with 1 REAL8 vector input and 1 REAL8 vector output (D2D) ----------
192 #define TESTBENCH_VECTORMATH_D2D(name,in) \
193  { \
194  XLAL_CHECK ( XLALVector##name##REAL8_GEN( xOutRefD, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
195  tic = XLALGetCPUTime(); \
196  for (UINT4 l=0; l < Nruns; l ++ ) { \
197  XLAL_CHECK ( XLALVector##name##REAL8( xOutD, in, Ntrials ) == XLAL_SUCCESS, XLAL_EFUNC ); \
198  } \
199  toc = XLALGetCPUTime(); \
200  maxErr = maxRelerr = 0; \
201  for ( UINT4 i = 0; i < Ntrials; i ++ ) \
202  { \
203  REAL8 err = fabs ( xOut[i] - xOutRef[i] ); \
204  REAL8 relerr = Relerrd ( err, xOutRef[i] ); \
205  maxErr = fmax ( err, maxErr ); \
206  maxRelerr = fmax ( relerr, maxRelerr ); \
207  } \
208  XLALPrintInfo ( "%-32s: %4.0f Mops/sec [maxErr = %7.2g (tol=%7.2g), maxRelerr = %7.2g (tol=%7.2g)]\n", \
209  XLALVector##name##REAL8_name, (REAL8)Ntrials * Nruns / (toc - tic)/1e6, maxErr, (abstol), maxRelerr, (reltol) ); \
210  XLAL_CHECK ( (maxErr <= (abstol)), XLAL_ETOL, "%s: absolute error (%g) exceeds tolerance (%g)\n", #name "REAL8", maxErr, abstol ); \
211  XLAL_CHECK ( (maxRelerr <= (reltol)), XLAL_ETOL, "%s: relative error (%g) exceeds tolerance (%g)\n", #name "REAL8", maxRelerr, reltol ); \
212  }
213 
214 // local types
215 typedef struct
216 {
217  INT4 randSeed; /**< allow user to specify random-number seed for reproducible noise-realizations */
218  INT4 Nruns; // number of repated timing 'runs' to average over in order to improve variance of result
219  INT4 inAlign; // alignment of input vectors; default is sizeof(void*), i.e. no particular alignment
220  INT4 outAlign; // alignment of output vectors; default is sizeof(void*), i.e. no particular alignment
221 } UserInput_t;
222 
223 
224 // ---------- main ----------
225 int
226 main ( int argc, char *argv[] )
227 {
228  UserInput_t XLAL_INIT_DECL(uvar_s);
229  UserInput_t *uvar = &uvar_s;
230 
231  uvar->randSeed = 1;
232  uvar->Nruns = 1;
233  uvar->inAlign = uvar->outAlign = sizeof(void*);
234  // ---------- register user-variable ----------
235  XLALRegisterUvarMember( randSeed, INT4, 's', OPTIONAL, "Random-number seed");
236  XLALRegisterUvarMember( Nruns, INT4, 'r', OPTIONAL, "Number of repeated timing 'runs' to average over (=improves variance)" );
237  XLALRegisterUvarMember( inAlign, INT4, 'a', OPTIONAL, "Alignment of input vectors; default is sizeof(void*), i.e. no particular alignment" );
238  XLALRegisterUvarMember( outAlign, INT4, 'b', OPTIONAL, "Alignment of output vectors; default is sizeof(void*), i.e. no particular alignment" );
239 
240  BOOLEAN should_exit = 0;
241  XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
242  if ( should_exit ) {
243  exit (1);
244  }
245 
246  srand ( uvar->randSeed );
247  XLAL_CHECK ( uvar->Nruns >= 1, XLAL_EDOM );
248  UINT4 Nruns = (UINT4)uvar->Nruns;
249 
250  UINT4 Ntrials = 1000000 + 7;
251 
252  INT4Vector *xOutI4;
253  INT4Vector *xOutRefI4;
254  XLAL_CHECK ( ( xOutI4 = XLALCreateINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
255  XLAL_CHECK ( ( xOutRefI4 = XLALCreateINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
256 
257  UINT4Vector *xOutU4;
258  UINT4Vector *xOutRefU4;
259  XLAL_CHECK ( ( xOutU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
260  XLAL_CHECK ( ( xOutRefU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
261 
262  REAL4VectorAligned *xIn_a, *xIn2_a, *xOut_a, *xOut2_a;
263  XLAL_CHECK ( ( xIn_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
264  XLAL_CHECK ( ( xIn2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
265  XLAL_CHECK ( ( xOut_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
266  XLAL_CHECK ( ( xOut2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
267  REAL4VectorAligned *xOutRef_a, *xOutRef2_a;
268  XLAL_CHECK ( (xOutRef_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
269  XLAL_CHECK ( (xOutRef2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
270 
271  // extract aligned REAL4 vectors from these
272  REAL4 *xIn = xIn_a->data;
273  REAL4 *xIn2 = xIn2_a->data;
274  REAL4 *xOut = xOut_a->data;
275  REAL4 *xOut2 = xOut2_a->data;
276  REAL4 *xOutRef = xOutRef_a->data;
277  REAL4 *xOutRef2 = xOutRef2_a->data;
278 
279  REAL8VectorAligned *xInD_a, *xIn2D_a, *xOutD_a, *xOutRefD_a;
280  XLAL_CHECK ( ( xInD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
281  XLAL_CHECK ( ( xIn2D_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
282  XLAL_CHECK ( ( xOutD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
283  XLAL_CHECK ( (xOutRefD_a= XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
284 
285  // extract aligned REAL8 vectors from these
286  REAL8 *xInD = xInD_a->data;
287  REAL8 *xIn2D = xIn2D_a->data;
288  REAL8 *xOutD = xOutD_a->data;
289  REAL8 *xOutRefD = xOutRefD_a->data;
290 
291  COMPLEX8VectorAligned *xInC_a, *xIn2C_a, *xOutC_a, *xOutRefC_a;
292  XLAL_CHECK ( ( xInC_a = XLALCreateCOMPLEX8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
293  XLAL_CHECK ( ( xIn2C_a = XLALCreateCOMPLEX8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
294  XLAL_CHECK ( ( xOutC_a = XLALCreateCOMPLEX8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
295  XLAL_CHECK ( (xOutRefC_a = XLALCreateCOMPLEX8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
296 
297  // extract aligned COMPLEX8 vectors from these
298  COMPLEX8 *xInC = xInC_a->data;
299  COMPLEX8 *xIn2C = xIn2C_a->data;
300  COMPLEX8 *xOutC = xOutC_a->data;
301  COMPLEX8 *xOutRefC = xOutRefC_a->data;
302 
303  REAL8 tic, toc;
304  REAL4 maxErr = 0, maxRelerr = 0;
305  REAL4 abstol, reltol;
306 
307  for ( UINT4 i = 0; i < Ntrials; i ++ ) {
308  xIn[i] = 2000 * ( frand() - 0.5 );
309  }
310  abstol = 2e-7, reltol = 1e-5;
311 
312  XLALPrintInfo ("Testing (INT4) for x in [-1000, 1000]\n");
313  // ==================== (INT4) ====================
314  TESTBENCH_VECTORMATH_S2I(INT4From,xIn);
315 
316 
317  XLALPrintInfo ("Testing sin(x), cos(x) for x in [-1000, 1000]\n");
318  // ==================== SIN() ====================
319  TESTBENCH_VECTORMATH_S2S(Sin,xIn);
320 
321  // ==================== COS() ====================
322  TESTBENCH_VECTORMATH_S2S(Cos,xIn);
323 
324  // ==================== SINCOS() ====================
325  TESTBENCH_VECTORMATH_S2SS(SinCos,xIn);
326 
327  // ==================== SINCOS(2PI*x) ====================
328  TESTBENCH_VECTORMATH_S2SS(SinCos2Pi,xIn);
329 
330  // ==================== EXP() ====================
331  XLALPrintInfo ("\nTesting exp(x) for x in [-10, 10]\n");
332  for ( UINT4 i = 0; i < Ntrials; i ++ ) {
333  xIn[i] = 20 * ( frand() - 0.5 );
334  }
335 
336  abstol = 4e-3, reltol = 3e-7;
337  TESTBENCH_VECTORMATH_S2S(Exp,xIn);
338 
339  // ==================== LOG() ====================
340  XLALPrintInfo ("\nTesting log(x) for x in (0, 10000]\n");
341  for ( UINT4 i = 0; i < Ntrials; i ++ ) {
342  xIn[i] = 10000.0f * frand() + 1e-6;
343  } // for i < Ntrials
344  abstol = 2e-6, reltol = 4e-7;
345 
346  TESTBENCH_VECTORMATH_S2S(Log,xIn);
347 
348  // ==================== ADD,MUL,ROUND ====================
349  for ( UINT4 i = 0; i < Ntrials; i ++ ) {
350  xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
351  xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
352  xInD[i] = -100000.0 + 200000.0 * frand() + 1e-6;
353  xIn2D[i]= -100000.0 + 200000.0 * frand() + 1e-6;
354  xInC[i] = -10000.0f + 20000.0f * frand() + 1e-6 + ( -10000.0f + 20000.0f * frand() + 1e-6 ) * _Complex_I;
355  xIn2C[i]= -10000.0f + 20000.0f * frand() + 1e-6 + ( -10000.0f + 20000.0f * frand() + 1e-6 ) * _Complex_I;
356  } // for i < Ntrials
357  abstol = 2e-7, reltol = 2e-7;
358 
359  XLALPrintInfo ("\nTesting round(x) for x in (-10000, 10000]\n");
360  TESTBENCH_VECTORMATH_S2S(Round,xIn);
361  TESTBENCH_VECTORMATH_D2D(Round,xInD);
362 
363  XLALPrintInfo ("\nTesting add,multiply,shift,scale(x,y) for x,y in (-10000, 10000]\n");
364  TESTBENCH_VECTORMATH_SS2S(Add,xIn,xIn2);
365  TESTBENCH_VECTORMATH_SS2S(Sub,xIn,xIn2);
366  TESTBENCH_VECTORMATH_SS2S(Multiply,xIn,xIn2);
367  TESTBENCH_VECTORMATH_SS2S(Max,xIn,xIn2);
368 
369  TESTBENCH_VECTORMATH_SS2S(Shift,xIn[0],xIn2);
370  TESTBENCH_VECTORMATH_SS2S(Scale,xIn[0],xIn2);
371 
372  TESTBENCH_VECTORMATH_DD2D(Add,xInD,xIn2D);
373  TESTBENCH_VECTORMATH_DD2D(Sub,xInD,xIn2D);
374  TESTBENCH_VECTORMATH_DD2D(Multiply,xInD,xIn2D);
375  TESTBENCH_VECTORMATH_DD2D(Max,xInD,xIn2D);
376 
377  TESTBENCH_VECTORMATH_DD2D(Shift,xInD[0],xIn2D);
378  TESTBENCH_VECTORMATH_DD2D(Scale,xInD[0],xIn2D);
379 
380  TESTBENCH_VECTORMATH_CC2C(Multiply,xInC,xIn2C);
381  TESTBENCH_VECTORMATH_CC2C(Add,xInC,xIn2C);
382 
383  TESTBENCH_VECTORMATH_CC2C(Scale,xInC[0],xIn2C);
384  TESTBENCH_VECTORMATH_CC2C(Shift,xInC[0],xIn2C);
385 
386  // ==================== FIND ====================
387  for ( UINT4 i = 0; i < Ntrials; i ++ ) {
388  xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
389  xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
390  } // for i < Ntrials
391 
392  XLALPrintInfo ("\nTesting find for x,y in (-10000, 10000]\n");
393  TESTBENCH_VECTORMATH_SS2uU(FindVectorLessEqual,xIn,xIn2);
394 
395  TESTBENCH_VECTORMATH_SS2uU(FindScalarLessEqual,xIn[0],xIn2);
396 
397  XLALPrintInfo ("\n");
398 
399  // ---------- clean up memory ----------
400  XLALDestroyINT4Vector ( xOutI4 );
401  XLALDestroyINT4Vector ( xOutRefI4 );
402 
403  XLALDestroyUINT4Vector ( xOutU4 );
404  XLALDestroyUINT4Vector ( xOutRefU4 );
405 
406  XLALDestroyREAL4VectorAligned ( xIn_a );
407  XLALDestroyREAL4VectorAligned ( xIn2_a );
408  XLALDestroyREAL4VectorAligned ( xOut_a );
409  XLALDestroyREAL4VectorAligned ( xOut2_a );
410 
411  XLALDestroyREAL4VectorAligned ( xOutRef_a );
412  XLALDestroyREAL4VectorAligned ( xOutRef2_a );
413 
414  XLALDestroyREAL8VectorAligned ( xInD_a );
415  XLALDestroyREAL8VectorAligned ( xIn2D_a );
416  XLALDestroyREAL8VectorAligned ( xOutD_a );
417  XLALDestroyREAL8VectorAligned ( xOutRefD_a );
418 
419  XLALDestroyCOMPLEX8VectorAligned ( xInC_a );
420  XLALDestroyCOMPLEX8VectorAligned ( xIn2C_a );
421  XLALDestroyCOMPLEX8VectorAligned ( xOutC_a );
422  XLALDestroyCOMPLEX8VectorAligned ( xOutRefC_a );
423 
424  XLALDestroyUserVars();
425 
426  LALCheckMemoryLeaks();
427 
428  return XLAL_SUCCESS;
429 
430 } // main()
LALCheckMemoryLeaks
void LALCheckMemoryLeaks(void)
Definition: LALMalloc.c:784
lalVCSInfoList
const LALVCSInfoList lalVCSInfoList
NULL-terminated list of VCS and build information for LAL and its dependencies
main
int main(int argc, char *argv[])
Definition: VectorMathTest.c:226
TESTBENCH_VECTORMATH_D2D
#define TESTBENCH_VECTORMATH_D2D(name, in)
Definition: VectorMathTest.c:192
TESTBENCH_VECTORMATH_SS2uU
#define TESTBENCH_VECTORMATH_SS2uU(name, in1, in2)
Definition: VectorMathTest.c:130
TESTBENCH_VECTORMATH_S2S
#define TESTBENCH_VECTORMATH_S2S(name, in)
Definition: VectorMathTest.c:59
TESTBENCH_VECTORMATH_S2I
#define TESTBENCH_VECTORMATH_S2I(name, in)
Definition: VectorMathTest.c:43
TESTBENCH_VECTORMATH_DD2D
#define TESTBENCH_VECTORMATH_DD2D(name, in1, in2)
Definition: VectorMathTest.c:147
TESTBENCH_VECTORMATH_S2SS
#define TESTBENCH_VECTORMATH_S2SS(name, in)
Definition: VectorMathTest.c:81
TESTBENCH_VECTORMATH_SS2S
#define TESTBENCH_VECTORMATH_SS2S(name, in1, in2)
Definition: VectorMathTest.c:107
TESTBENCH_VECTORMATH_CC2C
#define TESTBENCH_VECTORMATH_CC2C(name, in1, in2)
Definition: VectorMathTest.c:169
frand
#define frand()
Definition: VectorMathTest.c:37
XLALPrintInfo
int XLALPrintInfo(const char *fmt,...)
Definition: XLALError.c:90
BOOLEAN
unsigned char BOOLEAN
Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details.
Definition: LALAtomicDatatypes.h:39
REAL8
double REAL8
Double precision real floating-point number (8 bytes).
Definition: LALAtomicDatatypes.h:103
XLAL_INIT_DECL
#define XLAL_INIT_DECL(var,...)
C99 MACRO to declare and zero-initialize a variable, use as "type XLAL_INIT_DECL(var);".
Definition: LALAtomicDatatypes.h:69
UINT4
uint32_t UINT4
Four-byte unsigned integer.
Definition: LALAtomicDatatypes.h:59
COMPLEX8
float complex COMPLEX8
Single-precision floating-point complex number (8 bytes total)
Definition: LALAtomicDatatypes.h:119
INT4
int32_t INT4
Four-byte signed integer.
Definition: LALAtomicDatatypes.h:57
REAL4
float REAL4
Single precision real floating-point number (4 bytes).
Definition: LALAtomicDatatypes.h:102
XLALUserVarReadAllInput
int XLALUserVarReadAllInput(BOOLEAN *should_exit, int argc, char *argv[], const LALVCSInfoList vcs_list)
Put all the pieces together, and basically does everything: print help (if requested),...
Definition: UserInput.c:1064
XLALDestroyUserVars
void XLALDestroyUserVars(void)
Free all memory associated with user-variable linked list.
Definition: UserInput.c:349
XLALRegisterUvarMember
#define XLALRegisterUvarMember(name, type, option, category,...)
Shortcut macro for registering new user variables, which are accessed via the struct-pointer '*uvar'.
Definition: UserInput.h:157
XLALCreateINT4Vector
INT4Vector * XLALCreateINT4Vector(UINT4 length)
XLALDestroyUINT4Vector
void XLALDestroyUINT4Vector(UINT4Vector *vector)
XLALCreateUINT4Vector
UINT4Vector * XLALCreateUINT4Vector(UINT4 length)
XLALDestroyINT4Vector
void XLALDestroyINT4Vector(INT4Vector *vector)
XLALDestroyREAL4VectorAligned
void XLALDestroyREAL4VectorAligned(REAL4VectorAligned *in)
Free a REAL4VectorAligned struct.
XLALCreateCOMPLEX8VectorAligned
COMPLEX8VectorAligned * XLALCreateCOMPLEX8VectorAligned(const UINT4 length, const UINT4 align)
Create a new COMPLEX8VectorAligned struct with length length and alignment align.
XLALDestroyREAL8VectorAligned
void XLALDestroyREAL8VectorAligned(REAL8VectorAligned *in)
Free a REAL8VectorAligned struct.
XLALCreateREAL8VectorAligned
REAL8VectorAligned * XLALCreateREAL8VectorAligned(const UINT4 length, const UINT4 align)
Create a new REAL8VectorAligned struct with length length and alignment align.
XLALCreateREAL4VectorAligned
REAL4VectorAligned * XLALCreateREAL4VectorAligned(const UINT4 length, const UINT4 align)
Create a new REAL4VectorAligned struct with length length and alignment align.
XLALDestroyCOMPLEX8VectorAligned
void XLALDestroyCOMPLEX8VectorAligned(COMPLEX8VectorAligned *in)
Free a COMPLEX8VectorAligned struct.
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_SUCCESS
@ XLAL_SUCCESS
Success return value (not an error number)
Definition: XLALError.h:401
XLAL_EFUNC
@ XLAL_EFUNC
Internal function call failed bit: "or" this with existing error number.
Definition: XLALError.h:462
XLAL_EDOM
@ XLAL_EDOM
Input domain error.
Definition: XLALError.h:410
COMPLEX8VectorAligned
A special COMPLEX8Vector with n-byte aligned memory data array.
Definition: VectorMath.h:102
COMPLEX8VectorAligned::data
COMPLEX8 * data
start of aligned memory block
Definition: VectorMath.h:104
INT4Vector
Vector of type INT4, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:109
REAL4VectorAligned
A special REAL4Vector with n-byte aligned memory data array.
Definition: VectorMath.h:70
REAL4VectorAligned::data
REAL4 * data
start of aligned memory block
Definition: VectorMath.h:72
REAL8VectorAligned
A special REAL8Vector with n-byte aligned memory data array.
Definition: VectorMath.h:86
REAL8VectorAligned::data
REAL8 * data
start of aligned memory block
Definition: VectorMath.h:88
UINT4Vector
Vector of type UINT4, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:118
UserInput_t
Definition: UserInputTest.c:33
UserInput_t::randSeed
INT4 randSeed
allow user to specify random-number seed for reproducible noise-realizations
Definition: VectorMathTest.c:217
UserInput_t::inAlign
INT4 inAlign
Definition: VectorMathTest.c:219
UserInput_t::Nruns
INT4 Nruns
Definition: VectorMathTest.c:218
UserInput_t::outAlign
INT4 outAlign
Definition: VectorMathTest.c:220