6 from pybind11_tests
import numpy_dtypes
as m
8 np = pytest.importorskip(
"numpy")
11 @pytest.fixture(scope=
"module")
13 ld = np.dtype(
"longdouble")
16 "names": [
"bool_",
"uint_",
"float_",
"ldbl_"],
17 "formats": [
"?",
"u4",
"f4", f
"f{ld.itemsize}"],
18 "offsets": [0, 4, 8, (16
if ld.alignment > 4
else 12)],
23 @pytest.fixture(scope=
"module")
25 return np.dtype([(
"bool_",
"?"), (
"uint_",
"u4"), (
"float_",
"f4"), (
"ldbl_",
"g")])
29 from sys
import byteorder
31 e =
"<" if byteorder ==
"little" else ">"
33 "{{'names':['bool_','uint_','float_','ldbl_'],"
34 "'formats':['?','" + e +
"u4','" + e +
"f4','" + e +
"f{}'],"
35 "'offsets':[0,4,8,{}],'itemsize':{}}}"
40 ld = np.dtype(
"longdouble")
41 simple_ld_off = 12 + 4 * (ld.alignment > 4)
42 return dt_fmt().
format(ld.itemsize, simple_ld_off, simple_ld_off + ld.itemsize)
46 from sys
import byteorder
48 return "[('bool_','?'),('uint_','{e}u4'),('float_','{e}f4'),('ldbl_','{e}f{}')]".
format(
49 np.dtype(
"longdouble").itemsize, e=
"<" if byteorder ==
"little" else ">"
56 + 4 * (np.dtype(
"uint64").alignment > 4)
58 + 8 * (np.dtype(
"longdouble").alignment > 8)
63 ld = np.dtype(
"longdouble")
65 partial_size = partial_ld_off + ld.itemsize
66 partial_end_padding = partial_size % np.dtype(
"uint64").alignment
68 ld.itemsize, partial_ld_off, partial_size + partial_end_padding
73 ld = np.dtype(
"longdouble")
74 partial_nested_off = 8 + 8 * (ld.alignment > 8)
76 partial_size = partial_ld_off + ld.itemsize
77 partial_end_padding = partial_size % np.dtype(
"uint64").alignment
78 partial_nested_size = partial_nested_off * 2 + partial_size + partial_end_padding
79 return "{{'names':['a'],'formats':[{}],'offsets':[{}],'itemsize':{}}}".
format(
85 np.testing.assert_equal(actual, np.array(expected_data, dtype=expected_dtype))
89 with pytest.raises(RuntimeError)
as excinfo:
90 m.get_format_unbound()
92 "^NumPy type info missing for .*UnboundStruct.*$",
str(excinfo.value)
95 ld = np.dtype(
"longdouble")
96 ldbl_fmt = (
"4x" if ld.alignment > 4
else "") + ld.char
97 ss_fmt =
"^T{?:bool_:3xI:uint_:f:float_:" + ldbl_fmt +
":ldbl_:}"
98 dbl = np.dtype(
"double")
99 end_padding = ld.itemsize % np.dtype(
"uint64").alignment
101 "^T{?:bool_:3xI:uint_:f:float_:"
102 +
str(4 * (dbl.alignment > 4) + dbl.itemsize + 8 * (ld.alignment > 8))
104 + (
str(end_padding) +
"x}" if end_padding > 0
else "}")
106 nested_extra =
str(
max(8, ld.alignment))
107 assert m.print_format_descriptors() == [
109 "^T{?:bool_:I:uint_:f:float_:g:ldbl_:}",
110 "^T{" + ss_fmt +
":a:^T{?:bool_:I:uint_:f:float_:g:ldbl_:}:b:}",
112 "^T{" + nested_extra +
"x" + partial_fmt +
":a:" + nested_extra +
"x}",
114 "^T{(3)4s:a:(2)i:b:(3)B:c:1x(4, 2)f:d:}",
116 "^T{Zf:cflt:Zd:cdbl:}",
121 from sys
import byteorder
123 e =
"<" if byteorder ==
"little" else ">"
125 assert [x.replace(
" ",
"")
for x
in m.print_dtypes()] == [
128 f
"[('a',{simple_dtype_fmt()}),('b',{packed_dtype_fmt()})]",
131 "[('a','S3'),('b','S3')]",
133 "{'names':['a','b','c','d'],"
134 f
"'formats':[('S4',(3,)),('{e}i4',(2,)),('u1',(3,)),('{e}f4',(4,2))],"
135 "'offsets':[0,12,20,24],'itemsize':56}"
137 "[('e1','" + e +
"i8'),('e2','u1')]",
138 "[('x','i1'),('y','" + e +
"u8')]",
139 "[('cflt','" + e +
"c8'),('cdbl','" + e +
"c16')]",
145 "formats": [
"int32",
"float64"],
150 d2 = np.dtype([(
"a",
"i4"), (
"b",
"f4")])
151 assert m.test_dtype_ctors() == [
162 assert m.test_dtype_methods() == [
167 np.dtype(
"int32").itemsize,
168 simple_dtype.itemsize,
171 assert m.trailing_padding_dtype() == m.buffer_to_dtype(
172 np.zeros(1, m.trailing_padding_dtype())
175 expected_chars =
"bhilqBHILQefdgFDG?MmO"
176 assert m.test_dtype_kind() ==
list(
"iiiiiuuuuuffffcccbMmO")
177 assert m.test_dtype_char_() ==
list(expected_chars)
178 assert m.test_dtype_num() == [np.dtype(ch).num
for ch
in expected_chars]
179 assert m.test_dtype_byteorder() == [np.dtype(ch).byteorder
for ch
in expected_chars]
180 assert m.test_dtype_alignment() == [np.dtype(ch).alignment
for ch
in expected_chars]
181 assert m.test_dtype_flags() == [chr(np.dtype(ch).flags)
for ch
in expected_chars]
185 elements = [(
False, 0, 0.0, -0.0), (
True, 1, 1.5, -2.5), (
False, 2, 3.0, -5.0)]
188 (m.create_rec_simple, simple_dtype),
189 (m.create_rec_packed, packed_dtype),
192 assert arr.dtype == dtype
197 assert arr.dtype == dtype
202 assert type(arr[0]) == np.void
203 assert type(arr[0].item()) == tuple
205 if dtype == simple_dtype:
206 assert m.print_rec_simple(arr) == [
212 assert m.print_rec_packed(arr) == [
218 nested_dtype = np.dtype([(
"a", simple_dtype), (
"b", packed_dtype)])
220 arr = m.create_rec_nested(0)
221 assert arr.dtype == nested_dtype
224 arr = m.create_rec_nested(3)
225 assert arr.dtype == nested_dtype
229 ((
False, 0, 0.0, -0.0), (
True, 1, 1.5, -2.5)),
230 ((
True, 1, 1.5, -2.5), (
False, 2, 3.0, -5.0)),
231 ((
False, 2, 3.0, -5.0), (
True, 3, 4.5, -7.5)),
235 assert m.print_rec_nested(arr) == [
236 "n:a=s:0,0,0,-0;b=p:1,1,1.5,-2.5",
237 "n:a=s:1,1,1.5,-2.5;b=p:0,2,3,-5",
238 "n:a=s:0,2,3,-5;b=p:1,3,4.5,-7.5",
241 arr = m.create_rec_partial(3)
243 partial_dtype = arr.dtype
244 assert "" not in arr.dtype.fields
245 assert partial_dtype.itemsize > simple_dtype.itemsize
249 arr = m.create_rec_partial_nested(3)
251 assert "" not in arr.dtype.fields
252 assert "" not in arr.dtype.fields[
"a"][0].fields
253 assert arr.dtype.itemsize > partial_dtype.itemsize
254 np.testing.assert_equal(arr[
"a"], m.create_rec_partial(3))
258 data = np.arange(1, 7, dtype=
"int32")
260 np.testing.assert_array_equal(m.test_array_ctors(10 + i), data.reshape((3, 2)))
261 np.testing.assert_array_equal(m.test_array_ctors(20 + i), data.reshape((3, 2)))
263 np.testing.assert_array_equal(m.test_array_ctors(30 + i), data)
264 np.testing.assert_array_equal(m.test_array_ctors(40 + i), data)
268 arr = m.create_string_array(
True)
269 assert str(arr.dtype) ==
"[('a', 'S3'), ('b', 'S3')]"
270 assert m.print_string_array(arr) == [
277 assert arr[
"a"].tolist() == [b
"", b
"a", b
"ab", b
"abc"]
278 assert arr[
"b"].tolist() == [b
"", b
"a", b
"ab", b
"abc"]
279 arr = m.create_string_array(
False)
280 assert dtype == arr.dtype
284 from sys
import byteorder
286 e =
"<" if byteorder ==
"little" else ">"
288 arr = m.create_array_array(3)
289 assert str(arr.dtype).replace(
" ",
"") == (
290 "{'names':['a','b','c','d'],"
291 f
"'formats':[('S4',(3,)),('{e}i4',(2,)),('u1',(3,)),('{e}f4',(4,2))],"
292 "'offsets':[0,12,20,24],'itemsize':56}"
294 assert m.print_array_array(arr) == [
295 "a={{A,B,C,D},{K,L,M,N},{U,V,W,X}},b={0,1},"
296 "c={0,1,2},d={{0,1},{10,11},{20,21},{30,31}}",
297 "a={{W,X,Y,Z},{G,H,I,J},{Q,R,S,T}},b={1000,1001},"
298 "c={10,11,12},d={{100,101},{110,111},{120,121},{130,131}}",
299 "a={{S,T,U,V},{C,D,E,F},{M,N,O,P}},b={2000,2001},"
300 "c={20,21,22},d={{200,201},{210,211},{220,221},{230,231}}",
302 assert arr[
"a"].tolist() == [
303 [b
"ABCD", b
"KLMN", b
"UVWX"],
304 [b
"WXYZ", b
"GHIJ", b
"QRST"],
305 [b
"STUV", b
"CDEF", b
"MNOP"],
307 assert arr[
"b"].tolist() == [[0, 1], [1000, 1001], [2000, 2001]]
308 assert m.create_array_array(0).dtype == arr.dtype
312 from sys
import byteorder
314 e =
"<" if byteorder ==
"little" else ">"
316 arr = m.create_enum_array(3)
318 assert dtype == np.dtype([(
"e1", e +
"i8"), (
"e2",
"u1")])
319 assert m.print_enum_array(arr) == [
"e1=A,e2=X",
"e1=B,e2=Y",
"e1=A,e2=X"]
320 assert arr[
"e1"].tolist() == [-1, 1, -1]
321 assert arr[
"e2"].tolist() == [1, 2, 1]
322 assert m.create_enum_array(0).dtype == dtype
326 from sys
import byteorder
328 e =
"<" if byteorder ==
"little" else ">"
330 arr = m.create_complex_array(3)
332 assert dtype == np.dtype([(
"cflt", e +
"c8"), (
"cdbl", e +
"c16")])
333 assert m.print_complex_array(arr) == [
334 "c:(0,0.25),(0.5,0.75)",
335 "c:(1,1.25),(1.5,1.75)",
336 "c:(2,2.25),(2.5,2.75)",
338 assert arr[
"cflt"].tolist() == [0.0 + 0.25j, 1.0 + 1.25j, 2.0 + 2.25j]
339 assert arr[
"cdbl"].tolist() == [0.5 + 0.75j, 1.5 + 1.75j, 2.5 + 2.75j]
340 assert m.create_complex_array(0).dtype == dtype
345 doc(m.create_rec_nested)
346 ==
"create_rec_nested(arg0: int) -> numpy.ndarray[NestedStruct]"
353 m.create_rec_simple(n),
354 m.create_rec_packed(n),
355 m.create_rec_nested(n),
356 m.create_enum_array(n),
358 funcs = [m.f_simple, m.f_packed, m.f_nested]
360 for i, func
in enumerate(funcs):
361 for j, arr
in enumerate(arrays):
363 assert [
func(arr[k])
for k
in range(n)] == [k * 10
for k
in range(n)]
365 with pytest.raises(TypeError)
as excinfo:
367 assert "incompatible function arguments" in str(excinfo.value)
372 array = m.create_rec_simple(n)
373 values = m.f_simple_vectorized(array)
374 np.testing.assert_array_equal(values, [0, 10, 20])
375 array_2 = m.f_simple_pass_thru_vectorized(array)
376 np.testing.assert_array_equal(array, array_2)
381 assert s.astuple() == (
False, 0, 0.0, 0.0)
382 assert m.SimpleStruct.fromtuple(s.astuple()).astuple() == s.astuple()
385 assert m.f_simple(s) == 20
388 s_recarray = np.array([(
False, 2, 0.0, 0.0)], dtype=simple_dtype)
390 np.testing.assert_array_equal(m.f_simple_vectorized(s_recarray), [20])
393 s_scalar = s_recarray[0]
395 assert m.f_simple(s_scalar) == 20
399 s_recarray_scalar = s_recarray.reshape(())
400 assert isinstance(s_recarray_scalar, np.ndarray)
401 assert s_recarray_scalar.dtype == simple_dtype
402 with pytest.raises(TypeError)
as excinfo:
403 m.f_simple(s_recarray_scalar)
404 assert "incompatible function arguments" in str(excinfo.value)
406 assert m.f_simple(m.SimpleStruct.fromtuple(s_recarray_scalar.item())) == 20
409 s_array_object = np.array([s])
410 assert s_array_object.dtype == object
411 with pytest.raises(TypeError)
as excinfo:
412 m.f_simple_vectorized(s_array_object)
413 assert "incompatible function arguments" in str(excinfo.value)
415 s_array = np.array([s.astuple()], dtype=simple_dtype)
416 np.testing.assert_array_equal(m.f_simple_vectorized(s_array), [20])
420 with pytest.raises(RuntimeError)
as excinfo:
422 assert "dtype is already registered" in str(excinfo.value)
425 @pytest.mark.xfail(
"env.PYPY")
427 from sys
import getrefcount
431 start = getrefcount(fmt)
432 d = m.dtype_wrapper(fmt)
433 assert d
is np.dtype(
"f4")
436 assert getrefcount(fmt) == start
440 assert all(m.compare_buffer_info())