15 from numpy.testing
import assert_array_equal
19 return x == v
and type(x)
is t
23 print(
"checking module load ...", file=sys.stderr)
25 from lal
import globalvar
as lalglobalvar
28 lal_180_pi = lal.LAL_180_PI
29 print(
"PASSED module load", file=sys.stderr)
36 lal.swig_set_nice_error_handlers()
40 if "NASTY_ERROR_HANDLERS" in os.environ:
41 lal.swig_set_nasty_error_handlers()
43 lal.swig_set_nice_error_handlers()
49 @contextlib.contextmanager
52 with pytest.raises(*args, **kwargs):
63 frame = inspect.currentframe()
65 for v
in frame.f_back.f_locals:
66 if v.startswith(
"@py_assert"):
67 frame.f_back.f_locals[v] =
None
75 lal.CheckMemoryLeaks()
81 @pytest.mark.skipif(
lal.MEMORY_FUNCTIONS_DISABLED,
reason="LAL was built with MEMORY_FUNCTIONS_DISABLED",
)
83 """check memory allocation"""
84 print(
"checking memory allocation ...", file=sys.stderr)
87 mem2 = lal.CreateCOMPLEX8Vector(5)
88 mem3 = lal.CreateREAL8Vector(3)
89 mem4 = lal.CreateREAL4TimeSeries(
90 "test", lal.LIGOTimeGPS(0), 100, 0.1, lal.DimensionlessUnit, 10
93 "*** below should be an error message from CheckMemoryLeaks() ***",
97 with catch_errors(RuntimeError, match=
"Generic failure"):
100 "*** above should be an error message from CheckMemoryLeaks() ***",
108 print(
"PASSED memory allocation", file=sys.stderr)
112 """check object parent tracking"""
113 print(
"checking object parent tracking ...", file=sys.stderr)
114 a = lal.gsl_vector(3)
115 a.data = [1.1, 2.2, 3.3]
117 assert not b.flags[
"OWNDATA"]
118 assert_array_equal(b, [1.1, 2.2, 3.3])
120 assert_array_equal(b, [1.1, 2.2, 3.3])
121 ts = lal.CreateREAL8TimeSeries(
122 "test", lal.LIGOTimeGPS(0), 0, 0.1, lal.DimensionlessUnit, 10
124 ts.data.data = list(range(0, 10))
125 for i
in range(0, 7):
127 assert_array_equal(v.data, list(range(0, 10)))
129 assert_array_equal(v.data, list(range(0, 10)))
132 print(
"PASSED object parent tracking", file=sys.stderr)
136 """check equal return/first argument type handling"""
137 print(
"checking equal return/first argument type handling", file=sys.stderr)
138 sv = lal.CreateStringVector(
"1")
139 assert sv.length == 1
140 lal.AppendString2Vector(sv,
"2")
141 assert sv.length == 2
142 sv = lal.AppendString2Vector(sv,
"3")
143 assert sv.length == 3
144 sv2 = lal.AppendString2Vector(sv,
"4")
145 assert sv.length == 4
146 assert sv2.length == 4
151 ts = lal.CreateREAL8TimeSeries(
"ts", 800000000, 100, 0.1, lal.HertzUnit, 10)
152 assert ts.data.length == 10
153 lal.ResizeREAL8TimeSeries(ts, 0, 20)
154 assert ts.data.length == 20
155 ts = lal.ResizeREAL8TimeSeries(ts, 0, 30)
156 assert ts.data.length == 30
157 ts2 = lal.ResizeREAL8TimeSeries(ts, 0, 40)
158 assert ts.data.length == 40
159 assert ts2.data.length == 40
164 print(
"PASSED equal return/first argument type handling", file=sys.stderr)
168 """check string conversions"""
169 print(
"checking string conversions ...", file=sys.stderr)
170 strs = [
"a",
"bc",
"def"]
171 sv = lal.CreateStringVector(*strs)
172 assert sv.length == 3
173 assert_array_equal(sv.data.astype(object), strs)
176 strs.append(
"lmnopq")
177 sv = lal.AppendString2Vector(sv, strs[3])
178 assert sv.length == 4
179 for i
in range(0, 4):
180 assert sv.data[i] == strs[i]
183 print(
"PASSED string conversions", file=sys.stderr)
187 """check static vector/matrix conversions"""
188 print(
"checking static vector/matrix conversions ...", file=sys.stderr)
189 lalglobalvar.swig_lal_test_struct_vector[
191 ] = lalglobalvar.swig_lal_test_struct_const
193 lalglobalvar.swig_lal_test_struct_vector[0].n
194 == lalglobalvar.swig_lal_test_struct_const.n
197 lalglobalvar.swig_lal_test_struct_vector[0].i
198 == lalglobalvar.swig_lal_test_struct_const.i
201 lalglobalvar.swig_lal_test_struct_vector[0].f
202 == lalglobalvar.swig_lal_test_struct_const.f
205 lalglobalvar.swig_lal_test_struct_vector[0].str
206 == lalglobalvar.swig_lal_test_struct_const.str
209 lalglobalvar.swig_lal_test_struct_vector[0].vec,
210 lalglobalvar.swig_lal_test_struct_const.vec,
212 lalglobalvar.swig_lal_test_struct_matrix[
214 ] = lalglobalvar.swig_lal_test_struct_const
216 lalglobalvar.swig_lal_test_struct_matrix[0, 0].n
217 == lalglobalvar.swig_lal_test_struct_const.n
220 lalglobalvar.swig_lal_test_struct_matrix[0, 0].i
221 == lalglobalvar.swig_lal_test_struct_const.i
224 lalglobalvar.swig_lal_test_struct_matrix[0, 0].f
225 == lalglobalvar.swig_lal_test_struct_const.f
228 lalglobalvar.swig_lal_test_struct_matrix[0, 0].str
229 == lalglobalvar.swig_lal_test_struct_const.str
232 lalglobalvar.swig_lal_test_struct_matrix[0, 0].vec,
233 lalglobalvar.swig_lal_test_struct_const.vec,
235 sts = lal.swig_lal_test_struct()
236 assert len(sts.vec) == 3
237 assert len(sts.evec) == 3
238 assert sts.mat.shape == (2, 3)
240 assert_array_equal(sts.vec, [3, 2, 1])
241 sts.mat = [[4, 5, 6], (9, 8, 7)]
243 sts.mat = [[1.1, 2.3, 4.5], [6.5, 4.3, 2.1]]
244 assert_array_equal(sts.mat, [[4, 5, 6], [9, 8, 7]])
245 for i
in range(0, 3):
246 sts.evec[i] = 2 * i + 3
247 assert sts.evec[i] == (2 * i + 3)
249 assert not lalglobalvar.swig_lal_test_enum_vector.any()
250 assert not lalglobalvar.swig_lal_test_enum_matrix.any()
251 assert len(lalglobalvar.swig_lal_test_empty_INT4_vector) == 0
252 assert not lalglobalvar.swig_lal_test_INT4_vector.any()
253 assert not lalglobalvar.swig_lal_test_INT4_matrix.any()
254 assert not lalglobalvar.swig_lal_test_REAL8_vector.any()
255 assert not lalglobalvar.swig_lal_test_REAL8_matrix.any()
256 assert not lalglobalvar.swig_lal_test_COMPLEX8_vector.any()
257 assert not lalglobalvar.swig_lal_test_COMPLEX8_matrix.any()
258 lalglobalvar.swig_lal_test_INT4_vector[0] = 10
259 assert lalglobalvar.swig_lal_test_INT4_vector[0] == 10
260 lalglobalvar.swig_lal_test_INT4_matrix[0, 0] = 11
261 assert lalglobalvar.swig_lal_test_INT4_matrix[0, 0] == 11
262 lalglobalvar.swig_lal_test_INT4_vector = (
263 lalglobalvar.swig_lal_test_INT4_const_vector
265 assert_array_equal(lalglobalvar.swig_lal_test_INT4_vector, [1, 2, 4])
266 assert lalglobalvar.swig_lal_test_INT4_const_vector[2] == 4
267 lalglobalvar.swig_lal_test_INT4_matrix = (
268 lalglobalvar.swig_lal_test_INT4_const_matrix
271 lalglobalvar.swig_lal_test_INT4_matrix,
272 [[1, 2, 4], [2, 4, 8]],
274 assert lalglobalvar.swig_lal_test_INT4_const_matrix[1, 2] == 8
276 lalglobalvar.swig_lal_test_INT4_const_vector(20)
277 lalglobalvar.swig_lal_test_REAL8_vector[0] = 3.4
278 assert lalglobalvar.swig_lal_test_REAL8_vector[0] == 3.4
279 lalglobalvar.swig_lal_test_REAL8_matrix[0, 0] = 5.6
280 assert lalglobalvar.swig_lal_test_REAL8_matrix[0, 0] == 5.6
281 lalglobalvar.swig_lal_test_COMPLEX8_vector[0] = complex(3.5, 4.75)
282 assert lalglobalvar.swig_lal_test_COMPLEX8_vector[0] == complex(3.5, 4.75)
283 lalglobalvar.swig_lal_test_COMPLEX8_matrix[0, 0] = complex(5.5, 6.25)
284 assert lalglobalvar.swig_lal_test_COMPLEX8_matrix[0, 0] == complex(5.5, 6.25)
285 print(
"PASSED static vector/matrix conversions", file=sys.stderr)
289 """check dynamic vector/matrix conversions"""
290 print(
"checking dynamic vector/matrix conversions ...", file=sys.stderr)
292 def check_dynamic_vector_matrix(iv, ivl, rv, rvl, cm, cms1, cms2):
293 iv.data = numpy.zeros(ivl, dtype=iv.data.dtype)
294 rv.data = numpy.zeros(rvl, dtype=rv.data.dtype)
295 cm.data = numpy.zeros((cms1, cms2), dtype=cm.data.dtype)
297 iv.data = [1, 3, 2, 4, 3]
298 assert_array_equal(iv.data, [1, 3, 2, 4, 3])
300 assert iv.data[3] == 7
302 rv.data = [1.2, 3.4, 2.6, 4.8, 3.5]
303 assert_array_equal(rv.data, [1.2, 3.4, 2.6, 4.8, 3.5])
304 rv.data[rvl - 1] = 7.5
305 assert rv.data[rvl - 1] == 7.5
311 assert_array_equal(rv.data, iv.data)
314 for i
in range(0, cms1):
315 for j
in range(0, cms2):
316 cm.data[i, j] = complex(i / 4.0, j / 2.0)
317 assert cm.data[2, 3] == complex(0.5, 1.5)
318 assert cm.data[3, 2] == complex(0.75, 1.0)
320 with pytest.warns(numpy.ComplexWarning):
321 iv.data[0] = cm.data[2, 3]
324 with pytest.warns(numpy.ComplexWarning):
325 rv.data[0] = cm.data[3, 2]
329 iv = lal.CreateINT4Vector(5)
330 rv = lal.CreateREAL8Vector(5)
331 cm = lal.CreateCOMPLEX8VectorSequence(4, 6)
332 check_dynamic_vector_matrix(
333 iv, iv.length, rv, rv.length, cm, cm.length, cm.vectorLength
338 rv0 = lal.CreateREAL8Vector(0)
339 assert rv0.length == 0
340 assert rv0.data
is None
342 rv1 = lal.CreateREAL8Vector(1)
346 print(
"PASSED dynamic vector/matrix conversions (LAL)", file=sys.stderr)
348 iv = lal.gsl_vector_int(5)
349 rv = lal.gsl_vector(5)
350 cm = lal.gsl_matrix_complex_float(4, 6)
351 check_dynamic_vector_matrix(iv, iv.size, rv, rv.size, cm, cm.size1, cm.size2)
355 rv1 = lal.gsl_vector(1)
358 print(
"PASSED dynamic vector/matrix conversions (GSL)", file=sys.stderr)
362 """check fixed and dynamic arrays typemaps"""
363 print(
"checking fixed and dynamic arrays typemaps ...", file=sys.stderr)
364 a1in = numpy.array([1.2, 3.5, 7.9], dtype=numpy.double)
366 assert_array_equal(lal.swig_lal_test_copyin_array1(a1in, 2.5), a1out)
367 a2in = numpy.array([[3, 2], [7, 6], [12, 10]], dtype=numpy.int32)
369 assert_array_equal(lal.swig_lal_test_copyin_array2(a2in, 15), a2out)
370 a3in = numpy.array([lal.LIGOTimeGPS(1234.5), lal.LIGOTimeGPS(678.9)])
372 assert_array_equal(lal.swig_lal_test_copyin_array3(a3in, 3), a3out)
374 lal.swig_lal_test_copyin_array1(
375 numpy.array([0, 0, 0, 0], dtype=numpy.double), 0
377 with pytest.raises(TypeError):
378 lal.swig_lal_test_copyin_array2(
379 numpy.array([[1.2, 3.4], [0, 0], [0, 0]], dtype=numpy.double), 0
384 print(
"PASSED fixed and dynamic arrays typemaps", file=sys.stderr)
388 """check input views of string array structs"""
389 print(
"checking input views of string array structs ...", file=sys.stderr)
390 svdat = [
"a",
"bc",
"def"]
391 sv = lal.CreateEmptyStringVector(len(svdat))
393 svout = lal.CreateEmptyStringVector(len(svdat))
394 svout.data = [
""] * len(svdat)
395 assert lal.swig_lal_test_viewin_LALStringVector(svout, sv)
396 assert all(map(
lambda x, y: x == y, svout.data, sv.data))
397 svout.data = [
""] * len(svdat)
398 assert lal.swig_lal_test_viewin_LALStringVector(svout, svdat)
399 assert all(map(
lambda x, y: x == y, svout.data, svdat))
401 assert lal.swig_lal_test_copyinout_LALStringVector(sv)
402 assert all(map(
lambda x, y: x == y.upper(), sv.data, svdat))
404 retn, sv = lal.swig_lal_test_copyinout_LALStringVector(sv)
406 assert all(map(
lambda x, y: x == y.upper(), sv.data, svdat))
408 retn, sv = lal.swig_lal_test_copyinout_LALStringVector(sv)
410 assert all(map(
lambda x, y: x == y.upper(), sv, svdat))
415 print(
"PASSED input views of string array structs", file=sys.stderr)
419 """check input views of numeric array structs"""
420 print(
"checking input views of numeric array structs ...", file=sys.stderr)
421 r4dat = numpy.array([1.2, 2.3, 3.4, 4.5, 5.6], dtype=numpy.float32)
422 r8dat = numpy.array([3.4, 4.5, 5.6, 6.7, 7.8, 8.9], dtype=numpy.float64)
424 numpy.vectorize(complex)(r4dat, 8 + r4dat), dtype=numpy.complex64
426 c16dat = numpy.array(
427 numpy.vectorize(complex)(r8dat, 16 + r8dat), dtype=numpy.complex128
429 r4 = lal.CreateREAL4Vector(len(r4dat))
431 r4out = lal.CreateREAL4Vector(len(r4dat))
432 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
433 assert lal.swig_lal_test_viewin_REAL4Vector(r4out, r4)
434 assert_array_equal(r4out.data, r4.data)
435 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
436 assert lal.swig_lal_test_viewin_REAL4Vector(r4out, r4dat)
437 assert_array_equal(r4out.data, r4dat)
438 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
439 assert lal.swig_lal_test_viewinout_REAL4Vector(r4out, r4)
440 assert_array_equal(2 * r4out.data, r4.data)
441 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
442 assert lal.swig_lal_test_viewinout_REAL4Vector(r4out, r4dat)
443 assert_array_equal(2 * r4out.data, r4dat)
445 assert lal.swig_lal_test_copyinout_REAL4Vector(r4)
446 assert_array_equal(r4.data, 3 * r4dat)
448 retn, r4 = lal.swig_lal_test_copyinout_REAL4Vector(r4)
450 assert_array_equal(r4.data, 3 * r4dat)
452 retn, r4 = lal.swig_lal_test_copyinout_REAL4Vector(r4)
454 assert_array_equal(r4, 3 * r4dat)
459 r8 = lal.CreateREAL8Vector(len(r8dat))
461 r8out = lal.CreateREAL8Vector(len(r8dat))
462 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
463 assert lal.swig_lal_test_viewin_REAL8Vector(r8out, r8)
464 assert_array_equal(r8out.data, r8.data)
465 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
466 assert lal.swig_lal_test_viewin_REAL8Vector(r8out, r8dat)
467 assert_array_equal(r8out.data, r8dat)
468 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
469 assert lal.swig_lal_test_viewinout_REAL8Vector(r8out, r8)
470 assert_array_equal(2 * r8out.data, r8.data)
471 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
472 assert lal.swig_lal_test_viewinout_REAL8Vector(r8out, r8dat)
473 assert_array_equal(2 * r8out.data, r8dat)
475 assert lal.swig_lal_test_copyinout_REAL8Vector(r8)
476 assert_array_equal(r8.data, 3 * r8dat)
478 retn, r8 = lal.swig_lal_test_copyinout_REAL8Vector(r8)
480 assert_array_equal(r8.data, 3 * r8dat)
482 retn, r8 = lal.swig_lal_test_copyinout_REAL8Vector(r8)
484 assert_array_equal(r8, 3 * r8dat)
489 c8 = lal.CreateCOMPLEX8Vector(len(c8dat))
491 c8out = lal.CreateCOMPLEX8Vector(len(c8dat))
492 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
493 assert lal.swig_lal_test_viewin_COMPLEX8Vector(c8out, c8)
494 assert_array_equal(c8out.data, c8.data)
495 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
496 assert lal.swig_lal_test_viewin_COMPLEX8Vector(c8out, c8dat)
497 assert_array_equal(c8out.data, c8dat)
498 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
499 assert lal.swig_lal_test_viewinout_COMPLEX8Vector(c8out, c8)
500 assert_array_equal(2 * c8out.data, c8.data)
501 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
502 assert lal.swig_lal_test_viewinout_COMPLEX8Vector(c8out, c8dat)
503 assert_array_equal(2 * c8out.data, c8dat)
505 assert lal.swig_lal_test_copyinout_COMPLEX8Vector(c8)
506 assert_array_equal(c8.data, 3 * c8dat)
508 retn, c8 = lal.swig_lal_test_copyinout_COMPLEX8Vector(c8)
510 assert_array_equal(c8.data, 3 * c8dat)
512 retn, c8 = lal.swig_lal_test_copyinout_COMPLEX8Vector(c8)
514 assert_array_equal(c8, 3 * c8dat)
519 c16 = lal.CreateCOMPLEX16Vector(len(c16dat))
521 c16out = lal.CreateCOMPLEX16Vector(len(c16dat))
522 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
523 assert lal.swig_lal_test_viewin_COMPLEX16Vector(c16out, c16)
524 assert_array_equal(c16out.data, c16.data)
525 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
526 assert lal.swig_lal_test_viewin_COMPLEX16Vector(c16out, c16dat)
527 assert_array_equal(c16out.data, c16dat)
528 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
529 assert lal.swig_lal_test_viewinout_COMPLEX16Vector(c16out, c16)
530 assert_array_equal(2 * c16out.data, c16.data)
531 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
532 assert lal.swig_lal_test_viewinout_COMPLEX16Vector(c16out, c16dat)
533 assert_array_equal(2 * c16out.data, c16dat)
535 assert lal.swig_lal_test_copyinout_COMPLEX16Vector(c16)
536 assert_array_equal(c16.data, 3 * c16dat)
538 retn, c16 = lal.swig_lal_test_copyinout_COMPLEX16Vector(c16)
540 assert_array_equal(c16.data, 3 * c16dat)
542 retn, c16 = lal.swig_lal_test_copyinout_COMPLEX16Vector(c16)
544 assert_array_equal(c16, 3 * c16dat)
549 r4dat = numpy.array([[1.2, 2.3, 3.4], [4.5, 5.6, 6.7]], dtype=numpy.float32)
550 r8dat = numpy.array([[3.4, 4.5], [5.6, 6.7], [7.8, 8.9]], dtype=numpy.float64)
552 numpy.vectorize(complex)(r4dat, 8 + r4dat), dtype=numpy.complex64
554 c16dat = numpy.array(
555 numpy.vectorize(complex)(r8dat, 16 + r8dat), dtype=numpy.complex128
557 r4 = lal.CreateREAL4VectorSequence(r4dat.shape[0], r4dat.shape[1])
559 r4out = lal.CreateREAL4VectorSequence(r4dat.shape[0], r4dat.shape[1])
560 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
561 assert lal.swig_lal_test_viewin_REAL4VectorSequence(r4out, r4)
562 assert_array_equal(r4out.data, r4.data)
563 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
564 assert lal.swig_lal_test_viewin_REAL4VectorSequence(r4out, r4dat)
565 assert_array_equal(r4out.data, r4dat)
566 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
567 assert lal.swig_lal_test_viewinout_REAL4VectorSequence(r4out, r4)
568 assert_array_equal(2 * r4out.data, r4.data)
569 r4out.data = numpy.zeros(numpy.shape(r4dat), dtype=r4dat.dtype)
570 assert lal.swig_lal_test_viewinout_REAL4VectorSequence(r4out, r4dat)
571 assert_array_equal(2 * r4out.data, r4dat)
573 assert lal.swig_lal_test_copyinout_REAL4VectorSequence(r4)
574 assert_array_equal(r4.data, 3 * r4dat)
576 retn, r4 = lal.swig_lal_test_copyinout_REAL4VectorSequence(r4)
578 assert_array_equal(r4.data, 3 * r4dat)
580 retn, r4 = lal.swig_lal_test_copyinout_REAL4VectorSequence(r4)
582 assert_array_equal(r4, 3 * r4dat)
587 r8 = lal.CreateREAL8VectorSequence(r8dat.shape[0], r8dat.shape[1])
589 r8out = lal.CreateREAL8VectorSequence(r8dat.shape[0], r8dat.shape[1])
590 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
591 assert lal.swig_lal_test_viewin_REAL8VectorSequence(r8out, r8)
592 assert_array_equal(r8out.data, r8.data)
593 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
594 assert lal.swig_lal_test_viewin_REAL8VectorSequence(r8out, r8dat)
595 assert_array_equal(r8out.data, r8dat)
596 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
597 assert lal.swig_lal_test_viewinout_REAL8VectorSequence(r8out, r8)
598 assert_array_equal(2 * r8out.data, r8.data)
599 r8out.data = numpy.zeros(numpy.shape(r8dat), dtype=r8dat.dtype)
600 assert lal.swig_lal_test_viewinout_REAL8VectorSequence(r8out, r8dat)
601 assert_array_equal(2 * r8out.data, r8dat)
603 assert lal.swig_lal_test_copyinout_REAL8VectorSequence(r8)
604 assert_array_equal(r8.data, 3 * r8dat)
606 retn, r8 = lal.swig_lal_test_copyinout_REAL8VectorSequence(r8)
608 assert_array_equal(r8.data, 3 * r8dat)
610 retn, r8 = lal.swig_lal_test_copyinout_REAL8VectorSequence(r8)
612 assert_array_equal(r8, 3 * r8dat)
617 c8 = lal.CreateCOMPLEX8VectorSequence(c8dat.shape[0], c8dat.shape[1])
619 c8out = lal.CreateCOMPLEX8VectorSequence(c8dat.shape[0], c8dat.shape[1])
620 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
621 assert lal.swig_lal_test_viewin_COMPLEX8VectorSequence(c8out, c8)
622 assert_array_equal(c8out.data, c8.data)
623 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
624 assert lal.swig_lal_test_viewin_COMPLEX8VectorSequence(c8out, c8dat)
625 assert_array_equal(c8out.data, c8dat)
626 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
627 assert lal.swig_lal_test_viewinout_COMPLEX8VectorSequence(c8out, c8)
628 assert_array_equal(2 * c8out.data, c8.data)
629 c8out.data = numpy.zeros(numpy.shape(c8dat), dtype=c8dat.dtype)
630 assert lal.swig_lal_test_viewinout_COMPLEX8VectorSequence(c8out, c8dat)
631 assert_array_equal(2 * c8out.data, c8dat)
633 assert lal.swig_lal_test_copyinout_COMPLEX8VectorSequence(c8)
634 assert_array_equal(c8.data, 3 * c8dat)
636 retn, c8 = lal.swig_lal_test_copyinout_COMPLEX8VectorSequence(c8)
638 assert_array_equal(c8.data, 3 * c8dat)
640 retn, c8 = lal.swig_lal_test_copyinout_COMPLEX8VectorSequence(c8)
642 assert_array_equal(c8, 3 * c8dat)
647 c16 = lal.CreateCOMPLEX16VectorSequence(c16dat.shape[0], c16dat.shape[1])
649 c16out = lal.CreateCOMPLEX16VectorSequence(c16dat.shape[0], c16dat.shape[1])
650 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
651 assert lal.swig_lal_test_viewin_COMPLEX16VectorSequence(c16out, c16)
652 assert_array_equal(c16out.data, c16.data)
653 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
654 assert lal.swig_lal_test_viewin_COMPLEX16VectorSequence(c16out, c16dat)
655 assert_array_equal(c16out.data, c16dat)
656 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
657 assert lal.swig_lal_test_viewinout_COMPLEX16VectorSequence(c16out, c16)
658 assert_array_equal(2 * c16out.data, c16.data)
659 c16out.data = numpy.zeros(numpy.shape(c16dat), dtype=c16dat.dtype)
660 assert lal.swig_lal_test_viewinout_COMPLEX16VectorSequence(c16out, c16dat)
661 assert_array_equal(2 * c16out.data, c16dat)
663 assert lal.swig_lal_test_copyinout_COMPLEX16VectorSequence(c16)
664 assert_array_equal(c16.data, 3 * c16dat)
666 retn, c16 = lal.swig_lal_test_copyinout_COMPLEX16VectorSequence(c16)
668 assert_array_equal(c16.data, 3 * c16dat)
670 retn, c16 = lal.swig_lal_test_copyinout_COMPLEX16VectorSequence(c16)
672 assert_array_equal(c16, 3 * c16dat)
677 print(
"PASSED input views of numeric array structs (LAL)", file=sys.stderr)
678 vfdat = numpy.array([1.2, 2.3, 3.4, 4.5, 5.6], dtype=numpy.float32)
679 vddat = numpy.array([3.4, 4.5, 5.6, 6.7, 7.8, 8.9], dtype=numpy.float64)
680 vcfdat = numpy.array(
681 numpy.vectorize(complex)(vfdat, 8 + vfdat), dtype=numpy.complex64
683 vcddat = numpy.array(
684 numpy.vectorize(complex)(vddat, 16 + vddat), dtype=numpy.complex128
686 vf = lal.gsl_vector_float(len(vfdat))
688 vfout = lal.gsl_vector_float(len(vfdat))
689 vfout.data = numpy.zeros(numpy.shape(vfdat), dtype=vfdat.dtype)
690 assert lal.swig_lal_test_viewin_gsl_vector_float(vfout, vf)
691 assert_array_equal(vfout.data, vf.data)
692 vfout.data = numpy.zeros(numpy.shape(vfdat), dtype=vfdat.dtype)
693 assert lal.swig_lal_test_viewin_gsl_vector_float(vfout, vfdat)
694 assert_array_equal(vfout.data, vfdat)
695 vfout.data = numpy.zeros(numpy.shape(vfdat), dtype=vfdat.dtype)
696 assert lal.swig_lal_test_viewinout_gsl_vector_float(vfout, vf)
697 assert_array_equal(2 * vfout.data, vf.data)
698 vfout.data = numpy.zeros(numpy.shape(vfdat), dtype=vfdat.dtype)
699 assert lal.swig_lal_test_viewinout_gsl_vector_float(vfout, vfdat)
700 assert_array_equal(2 * vfout.data, vfdat)
702 assert lal.swig_lal_test_copyinout_gsl_vector_float(vf)
703 assert_array_equal(vf.data, 3 * vfdat)
705 retn, vf = lal.swig_lal_test_copyinout_gsl_vector_float(vf)
707 assert_array_equal(vf.data, 3 * vfdat)
709 retn, vf = lal.swig_lal_test_copyinout_gsl_vector_float(vf)
711 assert_array_equal(vf, 3 * vfdat)
716 vd = lal.gsl_vector(len(vddat))
718 vdout = lal.gsl_vector(len(vddat))
719 vdout.data = numpy.zeros(numpy.shape(vddat), dtype=vddat.dtype)
720 assert lal.swig_lal_test_viewin_gsl_vector(vdout, vd)
721 assert_array_equal(vdout.data, vd.data)
722 vdout.data = numpy.zeros(numpy.shape(vddat), dtype=vddat.dtype)
723 assert lal.swig_lal_test_viewin_gsl_vector(vdout, vddat)
724 assert_array_equal(vdout.data, vddat)
725 vdout.data = numpy.zeros(numpy.shape(vddat), dtype=vddat.dtype)
726 assert lal.swig_lal_test_viewinout_gsl_vector(vdout, vd)
727 assert_array_equal(2 * vdout.data, vd.data)
728 vdout.data = numpy.zeros(numpy.shape(vddat), dtype=vddat.dtype)
729 assert lal.swig_lal_test_viewinout_gsl_vector(vdout, vddat)
730 assert_array_equal(2 * vdout.data, vddat)
732 assert lal.swig_lal_test_copyinout_gsl_vector(vd)
733 assert_array_equal(vd.data, 3 * vddat)
735 retn, vd = lal.swig_lal_test_copyinout_gsl_vector(vd)
737 assert_array_equal(vd.data, 3 * vddat)
739 retn, vd = lal.swig_lal_test_copyinout_gsl_vector(vd)
741 assert_array_equal(vd, 3 * vddat)
746 vcf = lal.gsl_vector_complex_float(len(vcfdat))
748 vcfout = lal.gsl_vector_complex_float(len(vcfdat))
749 vcfout.data = numpy.zeros(numpy.shape(vcfdat), dtype=vcfdat.dtype)
750 assert lal.swig_lal_test_viewin_gsl_vector_complex_float(vcfout, vcf)
751 assert_array_equal(vcfout.data, vcf.data)
752 vcfout.data = numpy.zeros(numpy.shape(vcfdat), dtype=vcfdat.dtype)
753 assert lal.swig_lal_test_viewin_gsl_vector_complex_float(vcfout, vcfdat)
754 assert_array_equal(vcfout.data, vcfdat)
755 vcfout.data = numpy.zeros(numpy.shape(vcfdat), dtype=vcfdat.dtype)
756 assert lal.swig_lal_test_viewinout_gsl_vector_complex_float(vcfout, vcf)
757 assert_array_equal(2 * vcfout.data, vcf.data)
758 vcfout.data = numpy.zeros(numpy.shape(vcfdat), dtype=vcfdat.dtype)
759 assert lal.swig_lal_test_viewinout_gsl_vector_complex_float(vcfout, vcfdat)
760 assert_array_equal(2 * vcfout.data, vcfdat)
762 assert lal.swig_lal_test_copyinout_gsl_vector_complex_float(vcf)
763 assert_array_equal(vcf.data, 3 * vcfdat)
765 retn, vcf = lal.swig_lal_test_copyinout_gsl_vector_complex_float(vcf)
767 assert_array_equal(vcf.data, 3 * vcfdat)
769 retn, vcf = lal.swig_lal_test_copyinout_gsl_vector_complex_float(vcf)
771 assert_array_equal(vcf, 3 * vcfdat)
776 vcd = lal.gsl_vector_complex(len(vcddat))
778 vcdout = lal.gsl_vector_complex(len(vcddat))
779 vcdout.data = numpy.zeros(numpy.shape(vcddat), dtype=vcddat.dtype)
780 assert lal.swig_lal_test_viewin_gsl_vector_complex(vcdout, vcd)
781 assert_array_equal(vcdout.data, vcd.data)
782 vcdout.data = numpy.zeros(numpy.shape(vcddat), dtype=vcddat.dtype)
783 assert lal.swig_lal_test_viewin_gsl_vector_complex(vcdout, vcddat)
784 assert_array_equal(vcdout.data, vcddat)
785 vcdout.data = numpy.zeros(numpy.shape(vcddat), dtype=vcddat.dtype)
786 assert lal.swig_lal_test_viewinout_gsl_vector_complex(vcdout, vcd)
787 assert_array_equal(2 * vcdout.data, vcd.data)
788 vcdout.data = numpy.zeros(numpy.shape(vcddat), dtype=vcddat.dtype)
789 assert lal.swig_lal_test_viewinout_gsl_vector_complex(vcdout, vcddat)
790 assert_array_equal(2 * vcdout.data, vcddat)
792 assert lal.swig_lal_test_copyinout_gsl_vector_complex(vcd)
793 assert_array_equal(vcd.data, 3 * vcddat)
795 retn, vcd = lal.swig_lal_test_copyinout_gsl_vector_complex(vcd)
797 assert_array_equal(vcd.data, 3 * vcddat)
799 retn, vcd = lal.swig_lal_test_copyinout_gsl_vector_complex(vcd)
801 assert_array_equal(vcd, 3 * vcddat)
806 mfdat = numpy.array([[1.2, 2.3, 3.4], [4.5, 5.6, 6.7]], dtype=numpy.float32)
807 mddat = numpy.array([[3.4, 4.5], [5.6, 6.7], [7.8, 8.9]], dtype=numpy.float64)
808 mcfdat = numpy.array(
809 numpy.vectorize(complex)(mfdat, 8 + mfdat), dtype=numpy.complex64
811 mcddat = numpy.array(
812 numpy.vectorize(complex)(mddat, 16 + mddat), dtype=numpy.complex128
814 mf = lal.gsl_matrix_float(mfdat.shape[0], mfdat.shape[1])
816 mfout = lal.gsl_matrix_float(mfdat.shape[0], mfdat.shape[1])
817 mfout.data = numpy.zeros(numpy.shape(mfdat), dtype=mfdat.dtype)
818 assert lal.swig_lal_test_viewin_gsl_matrix_float(mfout, mf)
819 assert_array_equal(mfout.data, mf.data)
820 mfout.data = numpy.zeros(numpy.shape(mfdat), dtype=mfdat.dtype)
821 assert lal.swig_lal_test_viewin_gsl_matrix_float(mfout, mfdat)
822 assert_array_equal(mfout.data, mfdat)
823 mfout.data = numpy.zeros(numpy.shape(mfdat), dtype=mfdat.dtype)
824 assert lal.swig_lal_test_viewinout_gsl_matrix_float(mfout, mf)
825 assert_array_equal(2 * mfout.data, mf.data)
826 mfout.data = numpy.zeros(numpy.shape(mfdat), dtype=mfdat.dtype)
827 assert lal.swig_lal_test_viewinout_gsl_matrix_float(mfout, mfdat)
828 assert_array_equal(2 * mfout.data, mfdat)
830 assert lal.swig_lal_test_copyinout_gsl_matrix_float(mf)
831 assert_array_equal(mf.data, 3 * mfdat)
833 retn, mf = lal.swig_lal_test_copyinout_gsl_matrix_float(mf)
835 assert_array_equal(mf.data, 3 * mfdat)
837 retn, mf = lal.swig_lal_test_copyinout_gsl_matrix_float(mf)
839 assert_array_equal(mf, 3 * mfdat)
844 md = lal.gsl_matrix(mddat.shape[0], mddat.shape[1])
846 mdout = lal.gsl_matrix(mddat.shape[0], mddat.shape[1])
847 mdout.data = numpy.zeros(numpy.shape(mddat), dtype=mddat.dtype)
848 assert lal.swig_lal_test_viewin_gsl_matrix(mdout, md)
849 assert_array_equal(mdout.data, md.data)
850 mdout.data = numpy.zeros(numpy.shape(mddat), dtype=mddat.dtype)
851 assert lal.swig_lal_test_viewin_gsl_matrix(mdout, mddat)
852 assert_array_equal(mdout.data, mddat)
853 mdout.data = numpy.zeros(numpy.shape(mddat), dtype=mddat.dtype)
854 assert lal.swig_lal_test_viewinout_gsl_matrix(mdout, md)
855 assert_array_equal(2 * mdout.data, md.data)
856 mdout.data = numpy.zeros(numpy.shape(mddat), dtype=mddat.dtype)
857 assert lal.swig_lal_test_viewinout_gsl_matrix(mdout, mddat)
858 assert_array_equal(2 * mdout.data, mddat)
860 assert lal.swig_lal_test_copyinout_gsl_matrix(md)
861 assert_array_equal(md.data, 3 * mddat)
863 retn, md = lal.swig_lal_test_copyinout_gsl_matrix(md)
865 assert_array_equal(md.data, 3 * mddat)
867 retn, md = lal.swig_lal_test_copyinout_gsl_matrix(md)
869 assert_array_equal(md, 3 * mddat)
874 mcf = lal.gsl_matrix_complex_float(mcfdat.shape[0], mcfdat.shape[1])
876 mcfout = lal.gsl_matrix_complex_float(mcfdat.shape[0], mcfdat.shape[1])
877 mcfout.data = numpy.zeros(numpy.shape(mcfdat), dtype=mcfdat.dtype)
878 assert lal.swig_lal_test_viewin_gsl_matrix_complex_float(mcfout, mcf)
879 assert_array_equal(mcfout.data, mcf.data)
880 mcfout.data = numpy.zeros(numpy.shape(mcfdat), dtype=mcfdat.dtype)
881 assert lal.swig_lal_test_viewin_gsl_matrix_complex_float(mcfout, mcfdat)
882 assert_array_equal(mcfout.data, mcfdat)
883 mcfout.data = numpy.zeros(numpy.shape(mcfdat), dtype=mcfdat.dtype)
884 assert lal.swig_lal_test_viewinout_gsl_matrix_complex_float(mcfout, mcf)
885 assert_array_equal(2 * mcfout.data, mcf.data)
886 mcfout.data = numpy.zeros(numpy.shape(mcfdat), dtype=mcfdat.dtype)
887 assert lal.swig_lal_test_viewinout_gsl_matrix_complex_float(mcfout, mcfdat)
888 assert_array_equal(2 * mcfout.data, mcfdat)
890 assert lal.swig_lal_test_copyinout_gsl_matrix_complex_float(mcf)
891 assert_array_equal(mcf.data, 3 * mcfdat)
893 retn, mcf = lal.swig_lal_test_copyinout_gsl_matrix_complex_float(mcf)
895 assert_array_equal(mcf.data, 3 * mcfdat)
897 retn, mcf = lal.swig_lal_test_copyinout_gsl_matrix_complex_float(mcf)
899 assert_array_equal(mcf, 3 * mcfdat)
904 mcd = lal.gsl_matrix_complex(mcddat.shape[0], mcddat.shape[1])
906 mcdout = lal.gsl_matrix_complex(mcddat.shape[0], mcddat.shape[1])
907 mcdout.data = numpy.zeros(numpy.shape(mcddat), dtype=mcddat.dtype)
908 assert lal.swig_lal_test_viewin_gsl_matrix_complex(mcdout, mcd)
909 assert_array_equal(mcdout.data, mcd.data)
910 mcdout.data = numpy.zeros(numpy.shape(mcddat), dtype=mcddat.dtype)
911 assert lal.swig_lal_test_viewin_gsl_matrix_complex(mcdout, mcddat)
912 assert_array_equal(mcdout.data, mcddat)
913 mcdout.data = numpy.zeros(numpy.shape(mcddat), dtype=mcddat.dtype)
914 assert lal.swig_lal_test_viewinout_gsl_matrix_complex(mcdout, mcd)
915 assert_array_equal(2 * mcdout.data, mcd.data)
916 mcdout.data = numpy.zeros(numpy.shape(mcddat), dtype=mcddat.dtype)
917 assert lal.swig_lal_test_viewinout_gsl_matrix_complex(mcdout, mcddat)
918 assert_array_equal(2 * mcdout.data, mcddat)
920 assert lal.swig_lal_test_copyinout_gsl_matrix_complex(mcd)
921 assert_array_equal(mcd.data, 3 * mcddat)
923 retn, mcd = lal.swig_lal_test_copyinout_gsl_matrix_complex(mcd)
925 assert_array_equal(mcd.data, 3 * mcddat)
927 retn, mcd = lal.swig_lal_test_copyinout_gsl_matrix_complex(mcd)
929 assert_array_equal(mcd, 3 * mcddat)
934 print(
"PASSED input views of numeric array structs (GSL)", file=sys.stderr)
936 def check_input_view_type_safety(f, a, b, expect_exception):
946 r4 = numpy.zeros(10, dtype=numpy.float32)
947 r8 = numpy.zeros(10, dtype=numpy.float64)
948 c8 = numpy.zeros(10, dtype=numpy.complex64)
949 c16 = numpy.zeros(10, dtype=numpy.complex128)
950 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL4Vector, r4, r4,
False)
951 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL4Vector, r4, r8,
True)
952 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL4Vector, r4, c8,
True)
953 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL4Vector, r4, c16,
True)
954 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL8Vector, r8, r4,
True)
955 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL8Vector, r8, r8,
False)
956 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL8Vector, r8, c8,
True)
957 check_input_view_type_safety(lal.swig_lal_test_viewinout_REAL8Vector, r8, c16,
True)
958 check_input_view_type_safety(
959 lal.swig_lal_test_viewinout_COMPLEX8Vector, c8, r4,
True
961 check_input_view_type_safety(
962 lal.swig_lal_test_viewinout_COMPLEX8Vector, c8, r8,
True
964 check_input_view_type_safety(
965 lal.swig_lal_test_viewinout_COMPLEX8Vector, c8, c8,
False
967 check_input_view_type_safety(
968 lal.swig_lal_test_viewinout_COMPLEX8Vector, c8, c16,
True
970 check_input_view_type_safety(
971 lal.swig_lal_test_viewinout_COMPLEX16Vector, c16, r4,
True
973 check_input_view_type_safety(
974 lal.swig_lal_test_viewinout_COMPLEX16Vector, c16, r8,
True
976 check_input_view_type_safety(
977 lal.swig_lal_test_viewinout_COMPLEX16Vector, c16, c8,
True
979 check_input_view_type_safety(
980 lal.swig_lal_test_viewinout_COMPLEX16Vector, c16, c16,
False
982 check_input_view_type_safety(
983 lal.swig_lal_test_viewinout_gsl_vector_float, r4, r4,
False
985 check_input_view_type_safety(
986 lal.swig_lal_test_viewinout_gsl_vector_float, r4, r8,
True
988 check_input_view_type_safety(
989 lal.swig_lal_test_viewinout_gsl_vector_float, r4, c8,
True
991 check_input_view_type_safety(
992 lal.swig_lal_test_viewinout_gsl_vector_float, r4, c16,
True
994 check_input_view_type_safety(lal.swig_lal_test_viewinout_gsl_vector, r8, r4,
True)
995 check_input_view_type_safety(lal.swig_lal_test_viewinout_gsl_vector, r8, r8,
False)
996 check_input_view_type_safety(lal.swig_lal_test_viewinout_gsl_vector, r8, c8,
True)
997 check_input_view_type_safety(lal.swig_lal_test_viewinout_gsl_vector, r8, c16,
True)
998 check_input_view_type_safety(
999 lal.swig_lal_test_viewinout_gsl_vector_complex_float, c8, r4,
True
1001 check_input_view_type_safety(
1002 lal.swig_lal_test_viewinout_gsl_vector_complex_float, c8, r8,
True
1004 check_input_view_type_safety(
1005 lal.swig_lal_test_viewinout_gsl_vector_complex_float, c8, c8,
False
1007 check_input_view_type_safety(
1008 lal.swig_lal_test_viewinout_gsl_vector_complex_float, c8, c16,
True
1010 check_input_view_type_safety(
1011 lal.swig_lal_test_viewinout_gsl_vector_complex, c16, r4,
True
1013 check_input_view_type_safety(
1014 lal.swig_lal_test_viewinout_gsl_vector_complex, c16, r8,
True
1016 check_input_view_type_safety(
1017 lal.swig_lal_test_viewinout_gsl_vector_complex, c16, c8,
True
1019 check_input_view_type_safety(
1020 lal.swig_lal_test_viewinout_gsl_vector_complex, c16, c16,
False
1027 print(
"PASSED input views of numeric array structs (type safety)", file=sys.stderr)
1031 """check FFT functions with input views"""
1032 print(
"check FFT functions with input views ...", file=sys.stderr)
1033 r4in = numpy.array(list(range(0, 32)), dtype=numpy.float32)
1034 r8in = numpy.array(list(range(0, 64)), dtype=numpy.float64)
1035 c8in = numpy.array(numpy.vectorize(complex)(8 + r4in, r4in), dtype=numpy.complex64)
1036 c16in = numpy.array(
1037 numpy.vectorize(complex)(16 + r8in, r8in), dtype=numpy.complex128
1039 c8inv = lal.CreateCOMPLEX8Vector(len(c8in))
1041 c8outv = lal.CreateCOMPLEX8Vector(len(c8in))
1042 plan = lal.CreateForwardCOMPLEX8FFTPlan(len(c8in), 0)
1043 lal.COMPLEX8VectorFFT(c8outv, c8inv, plan)
1044 c8out = numpy.zeros(numpy.shape(c8outv.data), dtype=c8outv.data.dtype)
1045 lal.COMPLEX8VectorFFT(c8out, c8in, plan)
1046 assert_array_equal(c8out, c8outv.data)
1051 c16inv = lal.CreateCOMPLEX16Vector(len(c16in))
1053 c16outv = lal.CreateCOMPLEX16Vector(len(c16in))
1054 plan = lal.CreateForwardCOMPLEX16FFTPlan(len(c16in), 0)
1055 lal.COMPLEX16VectorFFT(c16outv, c16inv, plan)
1056 c16out = numpy.zeros(numpy.shape(c16outv.data), dtype=c16outv.data.dtype)
1057 lal.COMPLEX16VectorFFT(c16out, c16in, plan)
1058 assert_array_equal(c16out, c16outv.data)
1063 r4inv = lal.CreateREAL4Vector(len(r4in))
1065 c8outv = lal.CreateCOMPLEX8Vector(len(r4in) // 2 + 1)
1066 plan = lal.CreateForwardREAL4FFTPlan(len(r4in), 0)
1067 lal.REAL4ForwardFFT(c8outv, r4inv, plan)
1068 c8out = numpy.zeros(numpy.shape(c8outv.data), dtype=c8outv.data.dtype)
1069 lal.REAL4ForwardFFT(c8out, r4in, plan)
1070 assert_array_equal(c8out, c8outv.data)
1075 c8inv = lal.CreateCOMPLEX8Vector(len(c8in))
1077 r4outv = lal.CreateREAL4Vector((len(c8in) - 1) * 2)
1078 plan = lal.CreateReverseREAL4FFTPlan((len(c8in) - 1) * 2, 0)
1079 lal.REAL4ReverseFFT(r4outv, c8inv, plan)
1080 r4out = numpy.zeros(numpy.shape(r4outv.data), dtype=r4outv.data.dtype)
1081 lal.REAL4ReverseFFT(r4out, c8in, plan)
1082 assert_array_equal(r4out, r4outv.data)
1087 r8inv = lal.CreateREAL8Vector(len(r8in))
1089 c16outv = lal.CreateCOMPLEX16Vector(len(r8in) // 2 + 1)
1090 plan = lal.CreateForwardREAL8FFTPlan(len(r8in), 0)
1091 lal.REAL8ForwardFFT(c16outv, r8inv, plan)
1092 c16out = numpy.zeros(numpy.shape(c16outv.data), dtype=c16outv.data.dtype)
1093 lal.REAL8ForwardFFT(c16out, r8in, plan)
1094 assert_array_equal(c16out, c16outv.data)
1099 c16inv = lal.CreateCOMPLEX16Vector(len(c16in))
1101 r8outv = lal.CreateREAL8Vector((len(c16in) - 1) * 2)
1102 plan = lal.CreateReverseREAL8FFTPlan((len(c16in) - 1) * 2, 0)
1103 lal.REAL8ReverseFFT(r8outv, c16inv, plan)
1104 r8out = numpy.zeros(numpy.shape(r8outv.data), dtype=r8outv.data.dtype)
1105 lal.REAL8ReverseFFT(r8out, c16in, plan)
1106 assert_array_equal(r8out, r8outv.data)
1111 r4inv = lal.CreateREAL4Vector(len(r4in))
1113 r4outv = lal.CreateREAL4Vector(len(r4in))
1114 plan = lal.CreateForwardREAL4FFTPlan(len(r4in), 0)
1115 lal.REAL4VectorFFT(r4outv, r4inv, plan)
1116 r4out = numpy.zeros(numpy.shape(r4outv.data), dtype=r4outv.data.dtype)
1117 lal.REAL4VectorFFT(r4out, r4in, plan)
1118 assert_array_equal(r4out, r4outv.data)
1123 r8inv = lal.CreateREAL8Vector(len(r8in))
1125 r8outv = lal.CreateREAL8Vector(len(r8in))
1126 plan = lal.CreateForwardREAL8FFTPlan(len(r8in), 0)
1127 lal.REAL8VectorFFT(r8outv, r8inv, plan)
1128 r8out = numpy.zeros(numpy.shape(r8outv.data), dtype=r8outv.data.dtype)
1129 lal.REAL8VectorFFT(r8out, r8in, plan)
1130 assert_array_equal(r8out, r8outv.data)
1135 r4inv = lal.CreateREAL4Vector(len(r4in))
1137 r4outv = lal.CreateREAL4Vector(len(r4in) // 2 + 1)
1138 plan = lal.CreateForwardREAL4FFTPlan(len(r4in), 0)
1139 lal.REAL4PowerSpectrum(r4outv, r4inv, plan)
1140 r4out = numpy.zeros(numpy.shape(r4outv.data), dtype=r4outv.data.dtype)
1141 lal.REAL4PowerSpectrum(r4out, r4in, plan)
1142 assert_array_equal(r4out, r4outv.data)
1147 r8inv = lal.CreateREAL8Vector(len(r8in))
1149 r8outv = lal.CreateREAL8Vector(len(r8in) // 2 + 1)
1150 plan = lal.CreateForwardREAL8FFTPlan(len(r8in), 0)
1151 lal.REAL8PowerSpectrum(r8outv, r8inv, plan)
1152 r8out = numpy.zeros(numpy.shape(r8outv.data), dtype=r8outv.data.dtype)
1153 lal.REAL8PowerSpectrum(r8out, r8in, plan)
1154 assert_array_equal(r8out, r8outv.data)
1159 print(
"PASSED FFT functions with input views ...", file=sys.stderr)
1163 """check dynamic array of pointers access"""
1164 print(
"checking dynamic array of pointers access ...", file=sys.stderr)
1165 ap = lal.swig_lal_test_Create_arrayofptrs(3)
1166 assert ap.length == 3
1167 for i
in range(0, ap.length):
1168 assert ap.data[i].length == 6
1169 for j
in range(0, ap.data[i].length):
1170 assert ap.data[i].data[j] == 42 * ap.length * i + j
1173 print(
"PASSED dynamic array of pointers access", file=sys.stderr)
1177 """check typemaps for strings and double pointers"""
1178 print(
"checking typemaps for strings and double pointers ...", file=sys.stderr)
1179 sts = lal.swig_lal_test_struct()
1180 ptr_ptr, ptr_null_ptr, null_ptr_ptr = lal.swig_lal_test_typemaps_string_ptrptr(
1181 "abcde",
"",
None, sts, 0,
None
1183 assert ptr_ptr == sts
1184 assert ptr_null_ptr
is not None
1185 assert null_ptr_ptr
is None
1192 for i
in range(1, 10):
1193 ptr_ptr = lal.swig_lal_test_typemaps_ptrptr(ptr_ptr)
1194 assert ptr_ptr
is not None
1195 assert ptr_ptr.n == i
1199 for i
in range(1, 10):
1200 ptr_ptr_list.append(lal.swig_lal_test_typemaps_ptrptr(ptr_ptr_list[-1]))
1201 assert ptr_ptr_list[-1]
is not None
1202 assert ptr_ptr_list[-1].n == i
1203 while len(ptr_ptr_list) > 0:
1204 assert ptr_ptr_list[-1]
is not None
1205 assert ptr_ptr_list[-1].n == i
1209 print(
"PASSED typemaps for strings and double pointers", file=sys.stderr)
1213 """check 'tm' struct conversions"""
1214 print(
"checking 'tm' struct conversions ...", file=sys.stderr)
1216 utc0 = [2011, 5, 11, 16, 57, 49, 2, 131, 0]
1217 assert lal.GPSToUTC(gps0) == tuple(utc0)
1218 assert lal.UTCToGPS(utc0) == gps0
1219 for i
in range(0, 10):
1220 gps = gps0 + i * 86400
1223 utc[6] = (utc[6] + i) % 7
1225 utc[8] = -1 + (i % 3)
1226 assert lal.GPSToUTC(gps)[0:8] == tuple(utc[0:8])
1227 assert lal.UTCToGPS(utc) == gps
1228 utc = lal.GPSToUTC(lal.UTCToGPS(utc))
1229 dt = datetime.datetime(*utc[0:6])
1230 assert utc[6] == dt.weekday()
1232 print(
"PASSED 'tm' struct conversions", file=sys.stderr)
1236 """check LIGOTimeGPS operations"""
1237 print(
"checking LIGOTimeGPS operations ...", file=sys.stderr)
1238 from lal
import LIGOTimeGPS
1243 assert t0 !=
None and not t0
is None
1246 assert not t0
and t1
and t2
1250 assert t1 == t2
and t1 >= t2
and t2 >= t1
1251 assert abs(-t1) == t1
1252 assert float(t1) == 10.5
1257 assert t2 + 5.5 >= t1
and t2 + 3 != t2
1269 assert t1 > t2
and t2 < t1
and t1 >= t2
and t2 <= t1
1273 "-47044285.062262587"
1277 ==
LIGOTimeGPS(
"-914984.929117316") * 7.1502318572066237
1284 ==
LIGOTimeGPS(
"-914984.929117316") / 7.1502318572066237
1287 assert str(t1) ==
"812345678.25"
1288 assert type(eval(repr(t1)))
is type(t1)
1289 assert eval(repr(t1)) == t1
1291 LIGOTimeGPS(1100000000).asutcstr() ==
"Fri, 14 Nov 2014 11:33:04 +0000"
1295 ==
"Fri, 14 Nov 2014 11:33:04.0000001 +0000"
1297 assert LIGOTimeGPS(0, 0).asutcstr() ==
"Sun, 06 Jan 1980 00:00:00 +0000"
1298 assert LIGOTimeGPS(-1, 0).asutcstr() ==
"Sat, 05 Jan 1980 23:59:59 +0000"
1299 assert LIGOTimeGPS(0, -1).asutcstr() ==
"Sat, 05 Jan 1980 23:59:59.999999999 +0000"
1300 assert int(t1) == 812345678
1301 assert t1.ns() == 812345678250000000
1302 assert hash(t1) == 1049484238
1303 t4struct = lal.swig_lal_test_gps()
1305 assert t4struct.t == 1234.5
1309 "*** below should be error messages from LIGOTimeGPS constructor ***",
1312 with pytest.raises(RuntimeError):
1314 with pytest.raises(RuntimeError):
1317 "*** above should be error messages from LIGOTimeGPS constructor ***",
1320 assert lal.swig_lal_test_noptrgps(
1322 ) == lal.swig_lal_test_noptrgps(1234.5)
1324 "*** below should be error messages from LIGOTimeGPS constructor ***",
1327 with pytest.raises(RuntimeError):
1330 "*** above should be error messages from LIGOTimeGPS constructor ***",
1340 print(
"PASSED LIGOTimeGPS operations", file=sys.stderr)
1341 print(
"checking LIGOTimeGPS operations (Python specific) ...", file=sys.stderr)
1344 def __init__(self, s, ns):
1346 self.gpsNanoSeconds = ns
1348 tmy = my_gps_class(987, 654321)
1350 assert type(tsw)
is LIGOTimeGPS
1351 assert tsw.gpsSeconds == 987
1352 assert tsw.gpsNanoSeconds == 654321
1361 assert lal.swig_lal_test_noptrgps(tmy) == lal.swig_lal_test_noptrgps(tsw)
1364 print(
"PASSED LIGOTimeGPS operations (Python specific)", file=sys.stderr)
1368 """check LALUnit operations"""
1369 print(
"checking LALUnit operations ...", file=sys.stderr)
1370 u1 = lal.Unit(
"kg m s^-2")
1371 assert type(lal.Unit(u1))
is lal.Unit
1373 assert str(u1) ==
"m kg s^-2"
1374 u2 = lal.MeterUnit * lal.KiloGramUnit / lal.SecondUnit**2
1376 u2 = lal.MeterUnit ** (1, 2) * lal.KiloGramUnit ** (1, 2) * lal.SecondUnit**-1
1379 with pytest.raises((RuntimeError, TypeError)):
1380 lal.SecondUnit ** (1, 0)
1383 assert repr(u1) ==
"m^2 kg s^-2"
1384 u1 /= lal.SecondUnit
1386 assert u1 ==
"m^2 kg s^-3"
1388 assert u1 == lal.KiloUnit * lal.WattUnit
1389 assert u1 == 1000 * lal.WattUnit
1390 assert u1 == lal.WattUnit * 1000
1391 assert u1 == lal.MegaUnit / 1000 * lal.WattUnit
1392 assert int(u1) == 1000
1394 assert u1 == 100 * lal.MilliUnit * lal.WattUnit
1402 assert u1.norm() == u1
1406 print(
"PASSED LALUnit operations", file=sys.stderr)
1410 """check Python non-dynamic structs"""
1411 print(
"checking Python non-dynamic structs", file=sys.stderr)
1412 sts = lal.swig_lal_test_struct()
1416 with pytest.raises(AttributeError):
1419 sts.zzzzz =
"does not exist"
1421 t = lal.LIGOTimeGPS(1234)
1422 t.event =
"this happened"
1425 print(
"PASSED Python non-dynamic structs", file=sys.stderr)
1429 """check Python pickling"""
1430 print(
"checking Python pickling ...", file=sys.stderr)
1444 creator = getattr(lal,
"Create{}FrequencySeries".format(datatype))
1445 a = creator(
"foobar", lal.LIGOTimeGPS(1e9), 0, 1, lal.StrainUnit, 1024)
1446 a.data.data = numpy.arange(1024)
1447 pickled = pickle.dumps(a, 0)
1448 b = pickle.loads(pickled)
1449 assert type(a) == type(b)
1450 assert a.name == b.name
1451 assert a.epoch == b.epoch
1453 assert a.deltaF == b.deltaF
1454 assert a.sampleUnits == b.sampleUnits
1455 assert_array_equal(a.data.data, b.data.data)
1457 creator = getattr(lal,
"Create{}TimeSeries".format(datatype))
1458 a = creator(
"foobar", lal.LIGOTimeGPS(1e9), 0, 1, lal.StrainUnit, 1024)
1459 a.data.data = numpy.arange(1024)
1460 pickled = pickle.dumps(a, 0)
1461 b = pickle.loads(pickled)
1462 assert type(a) == type(b)
1463 assert a.name == b.name
1464 assert a.epoch == b.epoch
1466 assert a.deltaT == b.deltaT
1467 assert a.sampleUnits == b.sampleUnits
1468 assert_array_equal(a.data.data, b.data.data)
1469 print(
"PASSED Python pickling", file=sys.stderr)
1473 """check Python dict to LALDict typemap"""
1474 print(
"checking Python Python dict to LALDict typemap ...", file=sys.stderr)
1476 "str":
"A string value",
1477 "2-byte-unsigned:UINT2": 32767,
1478 "4-byte-unsigned:UINT4": 123456,
1479 "8-byte-unsigned:UINT8": 9223372036854775807,
1480 "2-byte-signed:INT2": -32768,
1481 "4-byte-signed:INT4": -123456,
1482 "8-byte-signed:INT8": 9223372036854775807,
1483 "single:REAL4": 987e6,
1484 "double:REAL8": -543e-21,
1485 "single complex:COMPLEX8": complex(987e6, -123e4),
1486 "double complex:COMPLEX16": complex(-543e-21, 345e43),
1488 laldict = lal.CreateDict()
1489 lal.DictInsertStringValue(laldict,
"str", pydict[
"str"])
1490 lal.DictInsertUINT2Value(
1491 laldict,
"2-byte-unsigned", pydict[
"2-byte-unsigned:UINT2"]
1493 lal.DictInsertUINT4Value(
1494 laldict,
"4-byte-unsigned", pydict[
"4-byte-unsigned:UINT4"]
1496 lal.DictInsertUINT8Value(
1497 laldict,
"8-byte-unsigned", pydict[
"8-byte-unsigned:UINT8"]
1499 lal.DictInsertINT2Value(laldict,
"2-byte-signed", pydict[
"2-byte-signed:INT2"])
1500 lal.DictInsertINT4Value(laldict,
"4-byte-signed", pydict[
"4-byte-signed:INT4"])
1501 lal.DictInsertINT8Value(laldict,
"8-byte-signed", pydict[
"8-byte-signed:INT8"])
1502 lal.DictInsertREAL4Value(laldict,
"single", pydict[
"single:REAL4"])
1503 lal.DictInsertREAL8Value(laldict,
"double", pydict[
"double:REAL8"])
1504 lal.DictInsertCOMPLEX8Value(
1505 laldict,
"single complex", pydict[
"single complex:COMPLEX8"]
1507 lal.DictInsertCOMPLEX16Value(
1508 laldict,
"double complex", pydict[
"double complex:COMPLEX16"]
1510 lal.swig_lal_test_pydict_to_laldict(laldict)
1511 lal.swig_lal_test_pydict_to_laldict(pydict)
1512 print(
"PASSED Python dict to LALDict typemap", file=sys.stderr)
1515 @pytest.mark.parametrize(
("inputs", "result"),
1517 ((10, numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1518 ((numpy.int8(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1519 ((numpy.int16(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1520 ((numpy.int32(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1521 ((numpy.int64(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1525 """Check conversion of NumPy fixed-width int types."""
1526 assert lal.swig_lal_test_numpy_int_types(*inputs) == result
1529 @pytest.mark.parametrize(
("inputs", "result"),
1531 ((10, numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1532 ((numpy.uint8(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1533 ((numpy.uint16(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1534 ((numpy.uint32(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1535 ((numpy.uint64(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1539 """Check conversion of NumPy fixed-width uint types."""
1540 assert lal.swig_lal_test_numpy_uint_types(*inputs) == result
1543 @pytest.mark.parametrize(
("inputs", "result"),
1545 ((numpy.int8(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1546 ((numpy.uint8(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1548 (numpy.float_(10), numpy.float16(20), numpy.float32(30), numpy.float64(40)),
1554 """Check conversion of NumPy fixed-width float types."""
1555 assert lal.swig_lal_test_numpy_flt_types(*inputs) == result
1558 @pytest.mark.parametrize(
("inputs", "result"),
1560 ((numpy.int8(10), numpy.int16(20), numpy.int32(30), numpy.int64(-40)), 20),
1561 ((numpy.uint8(10), numpy.uint16(20), numpy.uint32(30), numpy.uint64(40)), 100),
1563 (numpy.float_(10), numpy.float16(20), numpy.float32(30), numpy.float64(40)),
1569 numpy.complex64(20),
1570 numpy.complex64(30),
1571 numpy.complex128(40),
1578 """Check conversion of NumPy complex types."""
1579 assert lal.swig_lal_test_numpy_cpx_types(*inputs) == result
1582 @pytest.mark.parametrize(
("input_", "result"),
1584 (numpy.int8(123), 123),
1585 (numpy.int16(123), 123),
1586 (numpy.int32(123), 123),
1587 (numpy.int64(123), 123),
1591 """Check conversion of NumPy fixed-width types with LIGOTimeGPS."""
1592 assert int(lal.LIGOTimeGPS(input_)) == result
1595 if __name__ ==
"__main__":
1596 args = sys.argv[1:]
or [
"-v",
"-rs",
"--junit-xml=junit-SWIGTestLALPython.xml"]
1597 sys.exit(pytest.main(args=[__file__] + args))
1598 static size_t hash(const char *s)
static double f(double theta, double y, double xi)
def test_Python_pickling()
check Python pickling
def set_nice_error_handlers()
def test_input_views_of_string_array_structs()
check input views of string array structs
def test_conversion_of_numpy_fixed_width_types_ligotimegps(input_, result)
Check conversion of NumPy fixed-width types with LIGOTimeGPS.
def test_LIGOTimeGPS_operations()
check LIGOTimeGPS operations
def set_default_error_handlers()
def catch_errors(*args, **kwargs)
def test_conversion_of_numpy_fixed_width_types_cpx(inputs, result)
Check conversion of NumPy complex types.
def is_value_and_type(x, v, t)
def test_string_conversions()
check string conversions
def test_fixed_and_dynamic_arrays_typemaps()
check fixed and dynamic arrays typemaps
def test_memory_allocation()
check memory allocation
def test_LALUnit_operations()
check LALUnit operations
def test_dynamic_vector_matrix_conversions()
check dynamic vector/matrix conversions
def test_object_parent_tracking()
check object parent tracking
def test_conversion_of_numpy_fixed_width_types_int(inputs, result)
Check conversion of NumPy fixed-width int types.
def test_equal_return_first_argument_type_handling()
check equal return/first argument type handling
def test_dynamic_array_of_pointers_access()
check dynamic array of pointers access
def test_Python_dict_to_LALDict_typemap()
check Python dict to LALDict typemap
def test_Python_non_dynamic_structs()
check Python non-dynamic structs
def test_static_vector_matrix_conversions()
check static vector/matrix conversions
def test_input_views_of_numeric_array_structs()
check input views of numeric array structs
def test_tm_struct_conversions()
check 'tm' struct conversions
def test_conversion_of_numpy_fixed_width_types_uint(inputs, result)
Check conversion of NumPy fixed-width uint types.
def test_typemaps_for_strings_and_double_pointers()
check typemaps for strings and double pointers
def test_conversion_of_numpy_fixed_width_types_flt(inputs, result)
Check conversion of NumPy fixed-width float types.
def test_FFT_functions_with_input_views()
check FFT functions with input views
Epoch relative to GPS epoch, see LIGOTimeGPS type for more details.