LALPulsar  6.1.0.1-c9a8ef6
GSLHelpers.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2014 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 
20 #ifndef _GSLHELPERS_H
21 #define _GSLHELPERS_H
22 /// \cond DONT_DOXYGEN
23 
24 #include <gsl/gsl_errno.h>
25 #include <gsl/gsl_vector.h>
26 #include <gsl/gsl_matrix.h>
27 
28 #include <lal/XLALError.h>
29 #include <lal/XLALGSL.h>
30 
31 #ifndef SWIG // exclude from SWIG interface
32 
33 #define ALLOC_GSL_VAL(val, name, call) \
34  name = (call); \
35  XLAL_CHECK_VAL(val, (name) != NULL, XLAL_ENOMEM, #call " failed")
36 
37 #define ALLOC_GSL_1D_VAL(val, type, name, n) \
38  name = gsl_##type##_calloc(n); \
39  XLAL_CHECK_VAL(val, (name) != NULL, XLAL_ENOMEM, "gsl_"#type"_calloc(%zu) failed", ((size_t) n))
40 
41 #define ALLOC_GSL_2D_VAL(val, type, name, m, n) \
42  name = gsl_##type##_calloc(m, n); \
43  XLAL_CHECK_VAL(val, (name) != NULL, XLAL_ENOMEM, "gsl_"#type"_calloc(%zu,%zu) failed", ((size_t) m), ((size_t) n))
44 
45 #define CLONE_GSL_1D_VAL(val, type, dest, src) \
46  if ((src) != NULL) { \
47  ALLOC_GSL_1D_VAL(val, type, dest, (src)->size); \
48  gsl_##type##_memcpy(dest, src); \
49  } else { \
50  dest = NULL; \
51  }
52 
53 #define CLONE_GSL_2D_VAL(val, type, dest, src) \
54  if ((src) != NULL) { \
55  ALLOC_GSL_2D_VAL(val, type, dest, (src)->size1, (src)->size2); \
56  gsl_##type##_memcpy(dest, src); \
57  } else { \
58  dest = NULL; \
59  }
60 
61 #define COMPARE_GSL_1D_VAL(val, type, lhs, rhs, tol) \
62  do { \
63  if ((lhs) == NULL || (rhs) == NULL || (lhs)->size != (rhs)->size) { \
64  XLAL_ERROR_VAL(val, XLAL_ETOL, "Cannot compare '%s' and '%s': unequal or zero sizes", #lhs, #rhs); \
65  } else { \
66  for (size_t GH_i = 0; GH_i < (lhs)->size; ++GH_i) { \
67  const double GH_err = fabs(gsl_##type##_get(lhs, GH_i) - gsl_##type##_get(rhs, GH_i)); \
68  XLAL_CHECK_VAL(val, GH_err <= ((double)tol), XLAL_ETOL, "Element %zu of '%s' and '%s' differ by %g > %g", GH_i, #lhs, #rhs, GH_err, ((double)tol)); \
69  } \
70  } \
71  } while (0)
72 
73 #define COMPARE_GSL_2D_VAL(val, type, lhs, rhs, tol) \
74  do { \
75  if ((lhs) == NULL || (rhs) == NULL || (lhs)->size1 != (rhs)->size1 || (lhs)->size2 != (rhs)->size2) { \
76  XLAL_ERROR_VAL(val, XLAL_ETOL, "Cannot compare '%s' and '%s': unequal or zero sizes", #lhs, #rhs); \
77  } else { \
78  for (size_t GH_i = 0; GH_i < (lhs)->size1; ++GH_i) { \
79  for (size_t GH_j = 0; GH_j < (lhs)->size2; ++GH_j) { \
80  const double GH_err = gsl_##type##_get(lhs, GH_i, GH_j) - gsl_##type##_get(rhs, GH_i, GH_j); \
81  XLAL_CHECK_VAL(val, GH_err <= ((double)tol), XLAL_ETOL, "Elements (%zu,%zu) of '%s' and '%s' differ by %g > %g", GH_i, GH_j, #lhs, #rhs, GH_err, ((double)tol)); \
82  } \
83  } \
84  } \
85  } while (0)
86 
87 #define PRINT_GSL_1D(type, name, fmt) \
88  do { \
89  fprintf(stderr, "%s:%i ", strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__, __LINE__); \
90  fprintf(stderr, "%s = [", #name); \
91  for (size_t GH_i = 0; (name) != NULL && GH_i < (name)->size; ++GH_i) { \
92  fprintf(stderr, " " fmt, gsl_##type##_get(name, GH_i)); \
93  } \
94  fprintf(stderr, " ]\n"); \
95  } while (0)
96 
97 #define PRINT_GSL_2D(type, name, fmt) \
98  do { \
99  fprintf(stderr, "%s:%i ", strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__, __LINE__); \
100  fprintf(stderr, "%s = [\n", #name); \
101  for (size_t GH_i = 0; (name) != NULL && GH_i < (name)->size1; ++GH_i) { \
102  fprintf(stderr, " "); \
103  for (size_t GH_j = 0; GH_j < (name)->size2; ++GH_j) { \
104  fprintf(stderr, " " fmt, gsl_##type##_get(name, GH_i, GH_j)); \
105  } \
106  fprintf(stderr, ";\n"); \
107  } \
108  fprintf(stderr, "]\n"); \
109  } while (0)
110 
111 #define FREE_GSL(type, ...) \
112  do { \
113  gsl_##type *GH_ptrs[] = {__VA_ARGS__}; \
114  for (size_t GH_i = 0; GH_i < XLAL_NUM_ELEM(GH_ptrs); ++GH_i) { \
115  gsl_##type##_free(GH_ptrs[GH_i]); \
116  } \
117  } while (0)
118 
119 #define GALLOC(name, call) ALLOC_GSL_VAL(XLAL_FAILURE, name, call)
120 #define GALLOC_NULL(type, name, n) ALLOC_GSL_VAL(NULL, name, call)
121 #define GALLOC_MAIN(type, name, n) ALLOC_GSL_VAL(EXIT_FAILURE, name, call)
122 #define GALLOC_REAL8(type, name, n) ALLOC_GSL_VAL(XLAL_REAL8_FAIL_NAN, name, call)
123 #define GALLOC_REAL4(type, name, n) ALLOC_GSL_VAL(XLAL_REAL4_FAIL_NAN, name, call)
124 
125 #define GAPERM(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, permutation, name, n)
126 #define GAPERM_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, permutation, name, n)
127 #define GAPERM_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, permutation, name, n)
128 #define GAPERM_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, permutation, name, n)
129 #define GAPERM_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, permutation, name, n)
130 #define GCPERM(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, permutation, dest, src)
131 #define GCPERM_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, permutation, dest, src)
132 #define GCPERM_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, permutation, dest, src)
133 #define GCPERM_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, permutation, dest, src)
134 #define GCPERM_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, permutation, dest, src)
135 #define GCMPPERM(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, permutation, lhs, rhs, tol)
136 #define GCMPPERM_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, permutation, lhs, rhs, tol)
137 #define GCMPPERM_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, permutation, lhs, rhs, tol)
138 #define GCMPPERM_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, permutation, lhs, rhs, tol)
139 #define GCMPPERM_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, permutation, lhs, rhs, tol)
140 #define GPPERM(name, fmt) PRINT_GSL_1D(permutation, name, fmt)
141 #define GFPERM(...) FREE_GSL(permutation, __VA_ARGS__)
142 
143 #define GAVEC(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, vector, name, n)
144 #define GAVEC_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, vector, name, n)
145 #define GAVEC_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, vector, name, n)
146 #define GAVEC_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector, name, n)
147 #define GAVEC_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector, name, n)
148 #define GCVEC(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, vector, dest, src)
149 #define GCVEC_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, vector, dest, src)
150 #define GCVEC_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, vector, dest, src)
151 #define GCVEC_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector, dest, src)
152 #define GCVEC_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector, dest, src)
153 #define GCMPVEC(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, vector, lhs, rhs, tol)
154 #define GCMPVEC_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, vector, lhs, rhs, tol)
155 #define GCMPVEC_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, vector, lhs, rhs, tol)
156 #define GCMPVEC_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector, lhs, rhs, tol)
157 #define GCMPVEC_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector, lhs, rhs, tol)
158 #define GPVEC(name, fmt) PRINT_GSL_1D(vector, name, fmt)
159 #define GFVEC(...) FREE_GSL(vector, __VA_ARGS__)
160 
161 #define GAVECI(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, vector_int, name, n)
162 #define GAVECI_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, vector_int, name, n)
163 #define GAVECI_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, vector_int, name, n)
164 #define GAVECI_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_int, name, n)
165 #define GAVECI_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_int, name, n)
166 #define GCVECI(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, vector_int, dest, src)
167 #define GCVECI_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, vector_int, dest, src)
168 #define GCVECI_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, vector_int, dest, src)
169 #define GCVECI_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_int, dest, src)
170 #define GCVECI_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_int, dest, src)
171 #define GCMPVECI(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, vector_int, lhs, rhs, tol)
172 #define GCMPVECI_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, vector_int, lhs, rhs, tol)
173 #define GCMPVECI_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, vector_int, lhs, rhs, tol)
174 #define GCMPVECI_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_int, lhs, rhs, tol)
175 #define GCMPVECI_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_int, lhs, rhs, tol)
176 #define GPVECI(name, fmt) PRINT_GSL_1D(vector_int, name, fmt)
177 #define GFVECI(...) FREE_GSL(vector_int, __VA_ARGS__)
178 
179 #define GAVECU(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, vector_uint, name, n)
180 #define GAVECU_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, vector_uint, name, n)
181 #define GAVECU_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, vector_uint, name, n)
182 #define GAVECU_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_uint, name, n)
183 #define GAVECU_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_uint, name, n)
184 #define GCVECU(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, vector_uint, dest, src)
185 #define GCVECU_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, vector_uint, dest, src)
186 #define GCVECU_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, vector_uint, dest, src)
187 #define GCVECU_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_uint, dest, src)
188 #define GCVECU_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_uint, dest, src)
189 #define GCMPVECU(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, vector_uint, lhs, rhs, tol)
190 #define GCMPVECU_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, vector_uint, lhs, rhs, tol)
191 #define GCMPVECU_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, vector_uint, lhs, rhs, tol)
192 #define GCMPVECU_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_uint, lhs, rhs, tol)
193 #define GCMPVECU_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_uint, lhs, rhs, tol)
194 #define GPVECU(name, fmt) PRINT_GSL_1D(vector_uint, name, fmt)
195 #define GFVECU(...) FREE_GSL(vector_uint, __VA_ARGS__)
196 
197 #define GAVECLI(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, vector_long, name, n)
198 #define GAVECLI_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, vector_long, name, n)
199 #define GAVECLI_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, vector_long, name, n)
200 #define GAVECLI_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_long, name, n)
201 #define GAVECLI_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_long, name, n)
202 #define GCVECLI(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, vector_long, dest, src)
203 #define GCVECLI_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, vector_long, dest, src)
204 #define GCVECLI_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, vector_long, dest, src)
205 #define GCVECLI_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_long, dest, src)
206 #define GCVECLI_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_long, dest, src)
207 #define GCMPVECLI(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, vector_long, lhs, rhs, tol)
208 #define GCMPVECLI_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, vector_long, lhs, rhs, tol)
209 #define GCMPVECLI_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, vector_long, lhs, rhs, tol)
210 #define GCMPVECLI_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_long, lhs, rhs, tol)
211 #define GCMPVECLI_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_long, lhs, rhs, tol)
212 #define GPVECLI(name, fmt) PRINT_GSL_1D(vector_long, name, fmt)
213 #define GFVECLI(...) FREE_GSL(vector_long, __VA_ARGS__)
214 
215 #define GAVECLU(name, n) ALLOC_GSL_1D_VAL(XLAL_FAILURE, vector_ulong, name, n)
216 #define GAVECLU_NULL(name, n) ALLOC_GSL_1D_VAL(NULL, vector_ulong, name, n)
217 #define GAVECLU_MAIN(name, n) ALLOC_GSL_1D_VAL(EXIT_FAILURE, vector_ulong, name, n)
218 #define GAVECLU_REAL8(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_ulong, name, n)
219 #define GAVECLU_REAL4(name, n) ALLOC_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_ulong, name, n)
220 #define GCVECLU(dest, src) CLONE_GSL_1D_VAL(XLAL_FAILURE, vector_ulong, dest, src)
221 #define GCVECLU_NULL(dest, src) CLONE_GSL_1D_VAL(NULL, vector_ulong, dest, src)
222 #define GCVECLU_MAIN(dest, src) CLONE_GSL_1D_VAL(EXIT_FAILURE, vector_ulong, dest, src)
223 #define GCVECLU_REAL8(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_ulong, dest, src)
224 #define GCVECLU_REAL4(dest, src) CLONE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_ulong, dest, src)
225 #define GCMPVECLU(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_FAILURE, vector_ulong, lhs, rhs, tol)
226 #define GCMPVECLU_NULL(lhs, rhs, tol) COMPARE_GSL_1D_VAL(NULL, vector_ulong, lhs, rhs, tol)
227 #define GCMPVECLU_MAIN(lhs, rhs, tol) COMPARE_GSL_1D_VAL(EXIT_FAILURE, vector_ulong, lhs, rhs, tol)
228 #define GCMPVECLU_REAL8(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL8_FAIL_NAN, vector_ulong, lhs, rhs, tol)
229 #define GCMPVECLU_REAL4(lhs, rhs, tol) COMPARE_GSL_1D_VAL(XLAL_REAL4_FAIL_NAN, vector_ulong, lhs, rhs, tol)
230 #define GPVECLU(name, fmt) PRINT_GSL_1D(vector_ulong, name, fmt)
231 #define GFVECLU(...) FREE_GSL(vector_ulong, __VA_ARGS__)
232 
233 #define GAMAT(name, m, n) ALLOC_GSL_2D_VAL(XLAL_FAILURE, matrix, name, m, n)
234 #define GAMAT_NULL(name, m, n) ALLOC_GSL_2D_VAL(NULL, matrix, name, m, n)
235 #define GAMAT_MAIN(name, m, n) ALLOC_GSL_2D_VAL(EXIT_FAILURE, matrix, name, m, n)
236 #define GAMAT_REAL8(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix, name, m, n)
237 #define GAMAT_REAL4(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix, name, m, n)
238 #define GCMAT(dest, src) CLONE_GSL_2D_VAL(XLAL_FAILURE, matrix, dest, src)
239 #define GCMAT_NULL(dest, src) CLONE_GSL_2D_VAL(NULL, matrix, dest, src)
240 #define GCMAT_MAIN(dest, src) CLONE_GSL_2D_VAL(EXIT_FAILURE, matrix, dest, src)
241 #define GCMAT_REAL8(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix, dest, src)
242 #define GCMAT_REAL4(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix, dest, src)
243 #define GCMPMAT(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_FAILURE, matrix, lhs, rhs, tol)
244 #define GCMPMAT_NULL(lhs, rhs, tol) COMPARE_GSL_2D_VAL(NULL, matrix, lhs, rhs, tol)
245 #define GCMPMAT_MAIN(lhs, rhs, tol) COMPARE_GSL_2D_VAL(EXIT_FAILURE, matrix, lhs, rhs, tol)
246 #define GCMPMAT_REAL8(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix, lhs, rhs, tol)
247 #define GCMPMAT_REAL4(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix, lhs, rhs, tol)
248 #define GPMAT(name, fmt) PRINT_GSL_2D(matrix, name, fmt)
249 #define GFMAT(...) FREE_GSL(matrix, __VA_ARGS__)
250 
251 #define GAMATI(name, m, n) ALLOC_GSL_2D_VAL(XLAL_FAILURE, matrix_int, name, m, n)
252 #define GAMATI_NULL(name, m, n) ALLOC_GSL_2D_VAL(NULL, matrix_int, name, m, n)
253 #define GAMATI_MAIN(name, m, n) ALLOC_GSL_2D_VAL(EXIT_FAILURE, matrix_int, name, m, n)
254 #define GAMATI_REAL8(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_int, name, m, n)
255 #define GAMATI_REAL4(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_int, name, m, n)
256 #define GCMATI(dest, src) CLONE_GSL_2D_VAL(XLAL_FAILURE, matrix_int, dest, src)
257 #define GCMATI_NULL(dest, src) CLONE_GSL_2D_VAL(NULL, matrix_int, dest, src)
258 #define GCMATI_MAIN(dest, src) CLONE_GSL_2D_VAL(EXIT_FAILURE, matrix_int, dest, src)
259 #define GCMATI_REAL8(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_int, dest, src)
260 #define GCMATI_REAL4(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_int, dest, src)
261 #define GCMPMATI(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_FAILURE, matrix_int, lhs, rhs, tol)
262 #define GCMPMATI_NULL(lhs, rhs, tol) COMPARE_GSL_2D_VAL(NULL, matrix_int, lhs, rhs, tol)
263 #define GCMPMATI_MAIN(lhs, rhs, tol) COMPARE_GSL_2D_VAL(EXIT_FAILURE, matrix_int, lhs, rhs, tol)
264 #define GCMPMATI_REAL8(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_int, lhs, rhs, tol)
265 #define GCMPMATI_REAL4(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_int, lhs, rhs, tol)
266 #define GPMATI(name, fmt) PRINT_GSL_2D(matrix_int, name, fmt)
267 #define GFMATI(...) FREE_GSL(matrix_int, __VA_ARGS__)
268 
269 #define GAMATU(name, m, n) ALLOC_GSL_2D_VAL(XLAL_FAILURE, matrix_uint, name, m, n)
270 #define GAMATU_NULL(name, m, n) ALLOC_GSL_2D_VAL(NULL, matrix_uint, name, m, n)
271 #define GAMATU_MAIN(name, m, n) ALLOC_GSL_2D_VAL(EXIT_FAILURE, matrix_uint, name, m, n)
272 #define GAMATU_REAL8(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_uint, name, m, n)
273 #define GAMATU_REAL4(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_uint, name, m, n)
274 #define GCMATU(dest, src) CLONE_GSL_2D_VAL(XLAL_FAILURE, matrix_uint, dest, src)
275 #define GCMATU_NULL(dest, src) CLONE_GSL_2D_VAL(NULL, matrix_uint, dest, src)
276 #define GCMATU_MAIN(dest, src) CLONE_GSL_2D_VAL(EXIT_FAILURE, matrix_uint, dest, src)
277 #define GCMATU_REAL8(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_uint, dest, src)
278 #define GCMATU_REAL4(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_uint, dest, src)
279 #define GCMPMATU(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_FAILURE, matrix_uint, lhs, rhs, tol)
280 #define GCMPMATU_NULL(lhs, rhs, tol) COMPARE_GSL_2D_VAL(NULL, matrix_uint, lhs, rhs, tol)
281 #define GCMPMATU_MAIN(lhs, rhs, tol) COMPARE_GSL_2D_VAL(EXIT_FAILURE, matrix_uint, lhs, rhs, tol)
282 #define GCMPMATU_REAL8(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_uint, lhs, rhs, tol)
283 #define GCMPMATU_REAL4(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_uint, lhs, rhs, tol)
284 #define GPMATU(name, fmt) PRINT_GSL_2D(matrix_uint, name, fmt)
285 #define GFMATU(...) FREE_GSL(matrix_uint, __VA_ARGS__)
286 
287 #define GAMATLI(name, m, n) ALLOC_GSL_2D_VAL(XLAL_FAILURE, matrix_long, name, m, n)
288 #define GAMATLI_NULL(name, m, n) ALLOC_GSL_2D_VAL(NULL, matrix_long, name, m, n)
289 #define GAMATLI_MAIN(name, m, n) ALLOC_GSL_2D_VAL(EXIT_FAILURE, matrix_long, name, m, n)
290 #define GAMATLI_REAL8(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_long, name, m, n)
291 #define GAMATLI_REAL4(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_long, name, m, n)
292 #define GCMATLI(dest, src) CLONE_GSL_2D_VAL(XLAL_FAILURE, matrix_long, dest, src)
293 #define GCMATLI_NULL(dest, src) CLONE_GSL_2D_VAL(NULL, matrix_long, dest, src)
294 #define GCMATLI_MAIN(dest, src) CLONE_GSL_2D_VAL(EXIT_FAILURE, matrix_long, dest, src)
295 #define GCMATLI_REAL8(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_long, dest, src)
296 #define GCMATLI_REAL4(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_long, dest, src)
297 #define GCMPMATLI(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_FAILURE, matrix_long, lhs, rhs, tol)
298 #define GCMPMATLI_NULL(lhs, rhs, tol) COMPARE_GSL_2D_VAL(NULL, matrix_long, lhs, rhs, tol)
299 #define GCMPMATLI_MAIN(lhs, rhs, tol) COMPARE_GSL_2D_VAL(EXIT_FAILURE, matrix_long, lhs, rhs, tol)
300 #define GCMPMATLI_REAL8(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_long, lhs, rhs, tol)
301 #define GCMPMATLI_REAL4(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_long, lhs, rhs, tol)
302 #define GPMATLI(name, fmt) PRINT_GSL_2D(matrix_long, name, fmt)
303 #define GFMATLI(...) FREE_GSL(matrix_long, __VA_ARGS__)
304 
305 #define GAMATLU(name, m, n) ALLOC_GSL_2D_VAL(XLAL_FAILURE, matrix_ulong, name, m, n)
306 #define GAMATLU_NULL(name, m, n) ALLOC_GSL_2D_VAL(NULL, matrix_ulong, name, m, n)
307 #define GAMATLU_MAIN(name, m, n) ALLOC_GSL_2D_VAL(EXIT_FAILURE, matrix_ulong, name, m, n)
308 #define GAMATLU_REAL8(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_ulong, name, m, n)
309 #define GAMATLU_REAL4(name, m, n) ALLOC_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_ulong, name, m, n)
310 #define GCMATLU(dest, src) CLONE_GSL_2D_VAL(XLAL_FAILURE, matrix_ulong, dest, src)
311 #define GCMATLU_NULL(dest, src) CLONE_GSL_2D_VAL(NULL, matrix_ulong, dest, src)
312 #define GCMATLU_MAIN(dest, src) CLONE_GSL_2D_VAL(EXIT_FAILURE, matrix_ulong, dest, src)
313 #define GCMATLU_REAL8(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_ulong, dest, src)
314 #define GCMATLU_REAL4(dest, src) CLONE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_ulong, dest, src)
315 #define GCMPMATLU(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_FAILURE, matrix_ulong, lhs, rhs, tol)
316 #define GCMPMATLU_NULL(lhs, rhs, tol) COMPARE_GSL_2D_VAL(NULL, matrix_ulong, lhs, rhs, tol)
317 #define GCMPMATLU_MAIN(lhs, rhs, tol) COMPARE_GSL_2D_VAL(EXIT_FAILURE, matrix_ulong, lhs, rhs, tol)
318 #define GCMPMATLU_REAL8(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL8_FAIL_NAN, matrix_ulong, lhs, rhs, tol)
319 #define GCMPMATLU_REAL4(lhs, rhs, tol) COMPARE_GSL_2D_VAL(XLAL_REAL4_FAIL_NAN, matrix_ulong, lhs, rhs, tol)
320 #define GPMATLU(name, fmt) PRINT_GSL_2D(matrix_ulong, name, fmt)
321 #define GFMATLU(...) FREE_GSL(matrix_ulong, __VA_ARGS__)
322 
323 #endif // SWIG
324 
325 /// \endcond
326 #endif // _GSLHELPERS_H