111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com tests/test_numpy_dtypes.cpp -- Structured and compound NumPy dtypes 311986Sandreas.sandberg@arm.com 411986Sandreas.sandberg@arm.com Copyright (c) 2016 Ivan Smirnov 511986Sandreas.sandberg@arm.com 611986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 711986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 811986Sandreas.sandberg@arm.com*/ 911986Sandreas.sandberg@arm.com 1011986Sandreas.sandberg@arm.com#include "pybind11_tests.h" 1111986Sandreas.sandberg@arm.com#include <pybind11/numpy.h> 1211986Sandreas.sandberg@arm.com 1311986Sandreas.sandberg@arm.com#ifdef __GNUC__ 1411986Sandreas.sandberg@arm.com#define PYBIND11_PACKED(cls) cls __attribute__((__packed__)) 1511986Sandreas.sandberg@arm.com#else 1611986Sandreas.sandberg@arm.com#define PYBIND11_PACKED(cls) __pragma(pack(push, 1)) cls __pragma(pack(pop)) 1711986Sandreas.sandberg@arm.com#endif 1811986Sandreas.sandberg@arm.com 1911986Sandreas.sandberg@arm.comnamespace py = pybind11; 2011986Sandreas.sandberg@arm.com 2111986Sandreas.sandberg@arm.comstruct SimpleStruct { 2212037Sandreas.sandberg@arm.com bool bool_; 2312037Sandreas.sandberg@arm.com uint32_t uint_; 2412037Sandreas.sandberg@arm.com float float_; 2512037Sandreas.sandberg@arm.com long double ldbl_; 2611986Sandreas.sandberg@arm.com}; 2711986Sandreas.sandberg@arm.com 2811986Sandreas.sandberg@arm.comstd::ostream& operator<<(std::ostream& os, const SimpleStruct& v) { 2912037Sandreas.sandberg@arm.com return os << "s:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_; 3011986Sandreas.sandberg@arm.com} 3111986Sandreas.sandberg@arm.com 3214299Sbbruce@ucdavis.edustruct SimpleStructReordered { 3314299Sbbruce@ucdavis.edu bool bool_; 3414299Sbbruce@ucdavis.edu float float_; 3514299Sbbruce@ucdavis.edu uint32_t uint_; 3614299Sbbruce@ucdavis.edu long double ldbl_; 3714299Sbbruce@ucdavis.edu}; 3814299Sbbruce@ucdavis.edu 3911986Sandreas.sandberg@arm.comPYBIND11_PACKED(struct PackedStruct { 4012037Sandreas.sandberg@arm.com bool bool_; 4112037Sandreas.sandberg@arm.com uint32_t uint_; 4212037Sandreas.sandberg@arm.com float float_; 4312037Sandreas.sandberg@arm.com long double ldbl_; 4411986Sandreas.sandberg@arm.com}); 4511986Sandreas.sandberg@arm.com 4611986Sandreas.sandberg@arm.comstd::ostream& operator<<(std::ostream& os, const PackedStruct& v) { 4712037Sandreas.sandberg@arm.com return os << "p:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_; 4811986Sandreas.sandberg@arm.com} 4911986Sandreas.sandberg@arm.com 5011986Sandreas.sandberg@arm.comPYBIND11_PACKED(struct NestedStruct { 5111986Sandreas.sandberg@arm.com SimpleStruct a; 5211986Sandreas.sandberg@arm.com PackedStruct b; 5311986Sandreas.sandberg@arm.com}); 5411986Sandreas.sandberg@arm.com 5511986Sandreas.sandberg@arm.comstd::ostream& operator<<(std::ostream& os, const NestedStruct& v) { 5611986Sandreas.sandberg@arm.com return os << "n:a=" << v.a << ";b=" << v.b; 5711986Sandreas.sandberg@arm.com} 5811986Sandreas.sandberg@arm.com 5911986Sandreas.sandberg@arm.comstruct PartialStruct { 6012037Sandreas.sandberg@arm.com bool bool_; 6112037Sandreas.sandberg@arm.com uint32_t uint_; 6212037Sandreas.sandberg@arm.com float float_; 6311986Sandreas.sandberg@arm.com uint64_t dummy2; 6412037Sandreas.sandberg@arm.com long double ldbl_; 6511986Sandreas.sandberg@arm.com}; 6611986Sandreas.sandberg@arm.com 6711986Sandreas.sandberg@arm.comstruct PartialNestedStruct { 6811986Sandreas.sandberg@arm.com uint64_t dummy1; 6911986Sandreas.sandberg@arm.com PartialStruct a; 7011986Sandreas.sandberg@arm.com uint64_t dummy2; 7111986Sandreas.sandberg@arm.com}; 7211986Sandreas.sandberg@arm.com 7311986Sandreas.sandberg@arm.comstruct UnboundStruct { }; 7411986Sandreas.sandberg@arm.com 7511986Sandreas.sandberg@arm.comstruct StringStruct { 7611986Sandreas.sandberg@arm.com char a[3]; 7711986Sandreas.sandberg@arm.com std::array<char, 3> b; 7811986Sandreas.sandberg@arm.com}; 7911986Sandreas.sandberg@arm.com 8012391Sjason@lowepower.comstruct ComplexStruct { 8112391Sjason@lowepower.com std::complex<float> cflt; 8212391Sjason@lowepower.com std::complex<double> cdbl; 8312391Sjason@lowepower.com}; 8412391Sjason@lowepower.com 8512391Sjason@lowepower.comstd::ostream& operator<<(std::ostream& os, const ComplexStruct& v) { 8612391Sjason@lowepower.com return os << "c:" << v.cflt << "," << v.cdbl; 8712391Sjason@lowepower.com} 8812391Sjason@lowepower.com 8912391Sjason@lowepower.comstruct ArrayStruct { 9012391Sjason@lowepower.com char a[3][4]; 9112391Sjason@lowepower.com int32_t b[2]; 9212391Sjason@lowepower.com std::array<uint8_t, 3> c; 9312391Sjason@lowepower.com std::array<float, 2> d[4]; 9412391Sjason@lowepower.com}; 9512391Sjason@lowepower.com 9611986Sandreas.sandberg@arm.comPYBIND11_PACKED(struct StructWithUglyNames { 9711986Sandreas.sandberg@arm.com int8_t __x__; 9811986Sandreas.sandberg@arm.com uint64_t __y__; 9911986Sandreas.sandberg@arm.com}); 10011986Sandreas.sandberg@arm.com 10111986Sandreas.sandberg@arm.comenum class E1 : int64_t { A = -1, B = 1 }; 10211986Sandreas.sandberg@arm.comenum E2 : uint8_t { X = 1, Y = 2 }; 10311986Sandreas.sandberg@arm.com 10411986Sandreas.sandberg@arm.comPYBIND11_PACKED(struct EnumStruct { 10511986Sandreas.sandberg@arm.com E1 e1; 10611986Sandreas.sandberg@arm.com E2 e2; 10711986Sandreas.sandberg@arm.com}); 10811986Sandreas.sandberg@arm.com 10911986Sandreas.sandberg@arm.comstd::ostream& operator<<(std::ostream& os, const StringStruct& v) { 11011986Sandreas.sandberg@arm.com os << "a='"; 11111986Sandreas.sandberg@arm.com for (size_t i = 0; i < 3 && v.a[i]; i++) os << v.a[i]; 11211986Sandreas.sandberg@arm.com os << "',b='"; 11311986Sandreas.sandberg@arm.com for (size_t i = 0; i < 3 && v.b[i]; i++) os << v.b[i]; 11411986Sandreas.sandberg@arm.com return os << "'"; 11511986Sandreas.sandberg@arm.com} 11611986Sandreas.sandberg@arm.com 11712391Sjason@lowepower.comstd::ostream& operator<<(std::ostream& os, const ArrayStruct& v) { 11812391Sjason@lowepower.com os << "a={"; 11912391Sjason@lowepower.com for (int i = 0; i < 3; i++) { 12012391Sjason@lowepower.com if (i > 0) 12112391Sjason@lowepower.com os << ','; 12212391Sjason@lowepower.com os << '{'; 12312391Sjason@lowepower.com for (int j = 0; j < 3; j++) 12412391Sjason@lowepower.com os << v.a[i][j] << ','; 12512391Sjason@lowepower.com os << v.a[i][3] << '}'; 12612391Sjason@lowepower.com } 12712391Sjason@lowepower.com os << "},b={" << v.b[0] << ',' << v.b[1]; 12812391Sjason@lowepower.com os << "},c={" << int(v.c[0]) << ',' << int(v.c[1]) << ',' << int(v.c[2]); 12912391Sjason@lowepower.com os << "},d={"; 13012391Sjason@lowepower.com for (int i = 0; i < 4; i++) { 13112391Sjason@lowepower.com if (i > 0) 13212391Sjason@lowepower.com os << ','; 13312391Sjason@lowepower.com os << '{' << v.d[i][0] << ',' << v.d[i][1] << '}'; 13412391Sjason@lowepower.com } 13512391Sjason@lowepower.com return os << '}'; 13612391Sjason@lowepower.com} 13712391Sjason@lowepower.com 13811986Sandreas.sandberg@arm.comstd::ostream& operator<<(std::ostream& os, const EnumStruct& v) { 13911986Sandreas.sandberg@arm.com return os << "e1=" << (v.e1 == E1::A ? "A" : "B") << ",e2=" << (v.e2 == E2::X ? "X" : "Y"); 14011986Sandreas.sandberg@arm.com} 14111986Sandreas.sandberg@arm.com 14211986Sandreas.sandberg@arm.comtemplate <typename T> 14311986Sandreas.sandberg@arm.compy::array mkarray_via_buffer(size_t n) { 14411986Sandreas.sandberg@arm.com return py::array(py::buffer_info(nullptr, sizeof(T), 14511986Sandreas.sandberg@arm.com py::format_descriptor<T>::format(), 14611986Sandreas.sandberg@arm.com 1, { n }, { sizeof(T) })); 14711986Sandreas.sandberg@arm.com} 14811986Sandreas.sandberg@arm.com 14912037Sandreas.sandberg@arm.com#define SET_TEST_VALS(s, i) do { \ 15012037Sandreas.sandberg@arm.com s.bool_ = (i) % 2 != 0; \ 15112037Sandreas.sandberg@arm.com s.uint_ = (uint32_t) (i); \ 15212037Sandreas.sandberg@arm.com s.float_ = (float) (i) * 1.5f; \ 15312037Sandreas.sandberg@arm.com s.ldbl_ = (long double) (i) * -2.5L; } while (0) 15412037Sandreas.sandberg@arm.com 15511986Sandreas.sandberg@arm.comtemplate <typename S> 15611986Sandreas.sandberg@arm.compy::array_t<S, 0> create_recarray(size_t n) { 15711986Sandreas.sandberg@arm.com auto arr = mkarray_via_buffer<S>(n); 15811986Sandreas.sandberg@arm.com auto req = arr.request(); 15911986Sandreas.sandberg@arm.com auto ptr = static_cast<S*>(req.ptr); 16011986Sandreas.sandberg@arm.com for (size_t i = 0; i < n; i++) { 16112037Sandreas.sandberg@arm.com SET_TEST_VALS(ptr[i], i); 16211986Sandreas.sandberg@arm.com } 16311986Sandreas.sandberg@arm.com return arr; 16411986Sandreas.sandberg@arm.com} 16511986Sandreas.sandberg@arm.com 16611986Sandreas.sandberg@arm.comtemplate <typename S> 16711986Sandreas.sandberg@arm.compy::list print_recarray(py::array_t<S, 0> arr) { 16811986Sandreas.sandberg@arm.com const auto req = arr.request(); 16911986Sandreas.sandberg@arm.com const auto ptr = static_cast<S*>(req.ptr); 17011986Sandreas.sandberg@arm.com auto l = py::list(); 17112391Sjason@lowepower.com for (ssize_t i = 0; i < req.size; i++) { 17211986Sandreas.sandberg@arm.com std::stringstream ss; 17311986Sandreas.sandberg@arm.com ss << ptr[i]; 17411986Sandreas.sandberg@arm.com l.append(py::str(ss.str())); 17511986Sandreas.sandberg@arm.com } 17611986Sandreas.sandberg@arm.com return l; 17711986Sandreas.sandberg@arm.com} 17811986Sandreas.sandberg@arm.com 17911986Sandreas.sandberg@arm.compy::array_t<int32_t, 0> test_array_ctors(int i) { 18011986Sandreas.sandberg@arm.com using arr_t = py::array_t<int32_t, 0>; 18111986Sandreas.sandberg@arm.com 18211986Sandreas.sandberg@arm.com std::vector<int32_t> data { 1, 2, 3, 4, 5, 6 }; 18312391Sjason@lowepower.com std::vector<ssize_t> shape { 3, 2 }; 18412391Sjason@lowepower.com std::vector<ssize_t> strides { 8, 4 }; 18511986Sandreas.sandberg@arm.com 18611986Sandreas.sandberg@arm.com auto ptr = data.data(); 18711986Sandreas.sandberg@arm.com auto vptr = (void *) ptr; 18811986Sandreas.sandberg@arm.com auto dtype = py::dtype("int32"); 18911986Sandreas.sandberg@arm.com 19011986Sandreas.sandberg@arm.com py::buffer_info buf_ndim1(vptr, 4, "i", 6); 19111986Sandreas.sandberg@arm.com py::buffer_info buf_ndim1_null(nullptr, 4, "i", 6); 19211986Sandreas.sandberg@arm.com py::buffer_info buf_ndim2(vptr, 4, "i", 2, shape, strides); 19311986Sandreas.sandberg@arm.com py::buffer_info buf_ndim2_null(nullptr, 4, "i", 2, shape, strides); 19411986Sandreas.sandberg@arm.com 19511986Sandreas.sandberg@arm.com auto fill = [](py::array arr) { 19611986Sandreas.sandberg@arm.com auto req = arr.request(); 19711986Sandreas.sandberg@arm.com for (int i = 0; i < 6; i++) ((int32_t *) req.ptr)[i] = i + 1; 19811986Sandreas.sandberg@arm.com return arr; 19911986Sandreas.sandberg@arm.com }; 20011986Sandreas.sandberg@arm.com 20111986Sandreas.sandberg@arm.com switch (i) { 20211986Sandreas.sandberg@arm.com // shape: (3, 2) 20311986Sandreas.sandberg@arm.com case 10: return arr_t(shape, strides, ptr); 20411986Sandreas.sandberg@arm.com case 11: return py::array(shape, strides, ptr); 20511986Sandreas.sandberg@arm.com case 12: return py::array(dtype, shape, strides, vptr); 20611986Sandreas.sandberg@arm.com case 13: return arr_t(shape, ptr); 20711986Sandreas.sandberg@arm.com case 14: return py::array(shape, ptr); 20811986Sandreas.sandberg@arm.com case 15: return py::array(dtype, shape, vptr); 20911986Sandreas.sandberg@arm.com case 16: return arr_t(buf_ndim2); 21011986Sandreas.sandberg@arm.com case 17: return py::array(buf_ndim2); 21111986Sandreas.sandberg@arm.com // shape: (3, 2) - post-fill 21211986Sandreas.sandberg@arm.com case 20: return fill(arr_t(shape, strides)); 21311986Sandreas.sandberg@arm.com case 21: return py::array(shape, strides, ptr); // can't have nullptr due to templated ctor 21411986Sandreas.sandberg@arm.com case 22: return fill(py::array(dtype, shape, strides)); 21511986Sandreas.sandberg@arm.com case 23: return fill(arr_t(shape)); 21611986Sandreas.sandberg@arm.com case 24: return py::array(shape, ptr); // can't have nullptr due to templated ctor 21711986Sandreas.sandberg@arm.com case 25: return fill(py::array(dtype, shape)); 21811986Sandreas.sandberg@arm.com case 26: return fill(arr_t(buf_ndim2_null)); 21911986Sandreas.sandberg@arm.com case 27: return fill(py::array(buf_ndim2_null)); 22011986Sandreas.sandberg@arm.com // shape: (6, ) 22111986Sandreas.sandberg@arm.com case 30: return arr_t(6, ptr); 22211986Sandreas.sandberg@arm.com case 31: return py::array(6, ptr); 22311986Sandreas.sandberg@arm.com case 32: return py::array(dtype, 6, vptr); 22411986Sandreas.sandberg@arm.com case 33: return arr_t(buf_ndim1); 22511986Sandreas.sandberg@arm.com case 34: return py::array(buf_ndim1); 22611986Sandreas.sandberg@arm.com // shape: (6, ) 22711986Sandreas.sandberg@arm.com case 40: return fill(arr_t(6)); 22811986Sandreas.sandberg@arm.com case 41: return py::array(6, ptr); // can't have nullptr due to templated ctor 22911986Sandreas.sandberg@arm.com case 42: return fill(py::array(dtype, 6)); 23011986Sandreas.sandberg@arm.com case 43: return fill(arr_t(buf_ndim1_null)); 23111986Sandreas.sandberg@arm.com case 44: return fill(py::array(buf_ndim1_null)); 23211986Sandreas.sandberg@arm.com } 23311986Sandreas.sandberg@arm.com return arr_t(); 23411986Sandreas.sandberg@arm.com} 23511986Sandreas.sandberg@arm.com 23611986Sandreas.sandberg@arm.compy::list test_dtype_ctors() { 23711986Sandreas.sandberg@arm.com py::list list; 23811986Sandreas.sandberg@arm.com list.append(py::dtype("int32")); 23911986Sandreas.sandberg@arm.com list.append(py::dtype(std::string("float64"))); 24011986Sandreas.sandberg@arm.com list.append(py::dtype::from_args(py::str("bool"))); 24111986Sandreas.sandberg@arm.com py::list names, offsets, formats; 24211986Sandreas.sandberg@arm.com py::dict dict; 24311986Sandreas.sandberg@arm.com names.append(py::str("a")); names.append(py::str("b")); dict["names"] = names; 24411986Sandreas.sandberg@arm.com offsets.append(py::int_(1)); offsets.append(py::int_(10)); dict["offsets"] = offsets; 24511986Sandreas.sandberg@arm.com formats.append(py::dtype("int32")); formats.append(py::dtype("float64")); dict["formats"] = formats; 24611986Sandreas.sandberg@arm.com dict["itemsize"] = py::int_(20); 24711986Sandreas.sandberg@arm.com list.append(py::dtype::from_args(dict)); 24811986Sandreas.sandberg@arm.com list.append(py::dtype(names, formats, offsets, 20)); 24911986Sandreas.sandberg@arm.com list.append(py::dtype(py::buffer_info((void *) 0, sizeof(unsigned int), "I", 1))); 25011986Sandreas.sandberg@arm.com list.append(py::dtype(py::buffer_info((void *) 0, 0, "T{i:a:f:b:}", 1))); 25111986Sandreas.sandberg@arm.com return list; 25211986Sandreas.sandberg@arm.com} 25311986Sandreas.sandberg@arm.com 25414299Sbbruce@ucdavis.edustruct A {}; 25514299Sbbruce@ucdavis.edustruct B {}; 25614299Sbbruce@ucdavis.edu 25712391Sjason@lowepower.comTEST_SUBMODULE(numpy_dtypes, m) { 25812391Sjason@lowepower.com try { py::module::import("numpy"); } 25912391Sjason@lowepower.com catch (...) { return; } 26011986Sandreas.sandberg@arm.com 26111986Sandreas.sandberg@arm.com // typeinfo may be registered before the dtype descriptor for scalar casts to work... 26211986Sandreas.sandberg@arm.com py::class_<SimpleStruct>(m, "SimpleStruct"); 26311986Sandreas.sandberg@arm.com 26412037Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_); 26514299Sbbruce@ucdavis.edu PYBIND11_NUMPY_DTYPE(SimpleStructReordered, bool_, uint_, float_, ldbl_); 26612037Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(PackedStruct, bool_, uint_, float_, ldbl_); 26711986Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(NestedStruct, a, b); 26812037Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(PartialStruct, bool_, uint_, float_, ldbl_); 26911986Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(PartialNestedStruct, a); 27011986Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(StringStruct, a, b); 27112391Sjason@lowepower.com PYBIND11_NUMPY_DTYPE(ArrayStruct, a, b, c, d); 27211986Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE(EnumStruct, e1, e2); 27312391Sjason@lowepower.com PYBIND11_NUMPY_DTYPE(ComplexStruct, cflt, cdbl); 27411986Sandreas.sandberg@arm.com 27511986Sandreas.sandberg@arm.com // ... or after 27611986Sandreas.sandberg@arm.com py::class_<PackedStruct>(m, "PackedStruct"); 27711986Sandreas.sandberg@arm.com 27811986Sandreas.sandberg@arm.com PYBIND11_NUMPY_DTYPE_EX(StructWithUglyNames, __x__, "x", __y__, "y"); 27911986Sandreas.sandberg@arm.com 28012037Sandreas.sandberg@arm.com // If uncommented, this should produce a static_assert failure telling the user that the struct 28112037Sandreas.sandberg@arm.com // is not a POD type 28212037Sandreas.sandberg@arm.com// struct NotPOD { std::string v; NotPOD() : v("hi") {}; }; 28312037Sandreas.sandberg@arm.com// PYBIND11_NUMPY_DTYPE(NotPOD, v); 28412037Sandreas.sandberg@arm.com 28514299Sbbruce@ucdavis.edu // Check that dtypes can be registered programmatically, both from 28614299Sbbruce@ucdavis.edu // initializer lists of field descriptors and from other containers. 28714299Sbbruce@ucdavis.edu py::detail::npy_format_descriptor<A>::register_dtype( 28814299Sbbruce@ucdavis.edu {} 28914299Sbbruce@ucdavis.edu ); 29014299Sbbruce@ucdavis.edu py::detail::npy_format_descriptor<B>::register_dtype( 29114299Sbbruce@ucdavis.edu std::vector<py::detail::field_descriptor>{} 29214299Sbbruce@ucdavis.edu ); 29314299Sbbruce@ucdavis.edu 29412391Sjason@lowepower.com // test_recarray, test_scalar_conversion 29511986Sandreas.sandberg@arm.com m.def("create_rec_simple", &create_recarray<SimpleStruct>); 29611986Sandreas.sandberg@arm.com m.def("create_rec_packed", &create_recarray<PackedStruct>); 29712391Sjason@lowepower.com m.def("create_rec_nested", [](size_t n) { // test_signature 29812391Sjason@lowepower.com py::array_t<NestedStruct, 0> arr = mkarray_via_buffer<NestedStruct>(n); 29912391Sjason@lowepower.com auto req = arr.request(); 30012391Sjason@lowepower.com auto ptr = static_cast<NestedStruct*>(req.ptr); 30112391Sjason@lowepower.com for (size_t i = 0; i < n; i++) { 30212391Sjason@lowepower.com SET_TEST_VALS(ptr[i].a, i); 30312391Sjason@lowepower.com SET_TEST_VALS(ptr[i].b, i + 1); 30412391Sjason@lowepower.com } 30512391Sjason@lowepower.com return arr; 30612391Sjason@lowepower.com }); 30711986Sandreas.sandberg@arm.com m.def("create_rec_partial", &create_recarray<PartialStruct>); 30812391Sjason@lowepower.com m.def("create_rec_partial_nested", [](size_t n) { 30912391Sjason@lowepower.com py::array_t<PartialNestedStruct, 0> arr = mkarray_via_buffer<PartialNestedStruct>(n); 31012391Sjason@lowepower.com auto req = arr.request(); 31112391Sjason@lowepower.com auto ptr = static_cast<PartialNestedStruct*>(req.ptr); 31212391Sjason@lowepower.com for (size_t i = 0; i < n; i++) { 31312391Sjason@lowepower.com SET_TEST_VALS(ptr[i].a, i); 31412391Sjason@lowepower.com } 31512391Sjason@lowepower.com return arr; 31612391Sjason@lowepower.com }); 31711986Sandreas.sandberg@arm.com m.def("print_rec_simple", &print_recarray<SimpleStruct>); 31811986Sandreas.sandberg@arm.com m.def("print_rec_packed", &print_recarray<PackedStruct>); 31911986Sandreas.sandberg@arm.com m.def("print_rec_nested", &print_recarray<NestedStruct>); 32012391Sjason@lowepower.com 32112391Sjason@lowepower.com // test_format_descriptors 32212391Sjason@lowepower.com m.def("get_format_unbound", []() { return py::format_descriptor<UnboundStruct>::format(); }); 32312391Sjason@lowepower.com m.def("print_format_descriptors", []() { 32412391Sjason@lowepower.com py::list l; 32512391Sjason@lowepower.com for (const auto &fmt : { 32612391Sjason@lowepower.com py::format_descriptor<SimpleStruct>::format(), 32712391Sjason@lowepower.com py::format_descriptor<PackedStruct>::format(), 32812391Sjason@lowepower.com py::format_descriptor<NestedStruct>::format(), 32912391Sjason@lowepower.com py::format_descriptor<PartialStruct>::format(), 33012391Sjason@lowepower.com py::format_descriptor<PartialNestedStruct>::format(), 33112391Sjason@lowepower.com py::format_descriptor<StringStruct>::format(), 33212391Sjason@lowepower.com py::format_descriptor<ArrayStruct>::format(), 33312391Sjason@lowepower.com py::format_descriptor<EnumStruct>::format(), 33412391Sjason@lowepower.com py::format_descriptor<ComplexStruct>::format() 33512391Sjason@lowepower.com }) { 33612391Sjason@lowepower.com l.append(py::cast(fmt)); 33712391Sjason@lowepower.com } 33812391Sjason@lowepower.com return l; 33912391Sjason@lowepower.com }); 34012391Sjason@lowepower.com 34112391Sjason@lowepower.com // test_dtype 34212391Sjason@lowepower.com m.def("print_dtypes", []() { 34312391Sjason@lowepower.com py::list l; 34412391Sjason@lowepower.com for (const py::handle &d : { 34512391Sjason@lowepower.com py::dtype::of<SimpleStruct>(), 34612391Sjason@lowepower.com py::dtype::of<PackedStruct>(), 34712391Sjason@lowepower.com py::dtype::of<NestedStruct>(), 34812391Sjason@lowepower.com py::dtype::of<PartialStruct>(), 34912391Sjason@lowepower.com py::dtype::of<PartialNestedStruct>(), 35012391Sjason@lowepower.com py::dtype::of<StringStruct>(), 35112391Sjason@lowepower.com py::dtype::of<ArrayStruct>(), 35212391Sjason@lowepower.com py::dtype::of<EnumStruct>(), 35312391Sjason@lowepower.com py::dtype::of<StructWithUglyNames>(), 35412391Sjason@lowepower.com py::dtype::of<ComplexStruct>() 35512391Sjason@lowepower.com }) 35612391Sjason@lowepower.com l.append(py::str(d)); 35712391Sjason@lowepower.com return l; 35812391Sjason@lowepower.com }); 35912391Sjason@lowepower.com m.def("test_dtype_ctors", &test_dtype_ctors); 36012391Sjason@lowepower.com m.def("test_dtype_methods", []() { 36112391Sjason@lowepower.com py::list list; 36212391Sjason@lowepower.com auto dt1 = py::dtype::of<int32_t>(); 36312391Sjason@lowepower.com auto dt2 = py::dtype::of<SimpleStruct>(); 36412391Sjason@lowepower.com list.append(dt1); list.append(dt2); 36512391Sjason@lowepower.com list.append(py::bool_(dt1.has_fields())); list.append(py::bool_(dt2.has_fields())); 36612391Sjason@lowepower.com list.append(py::int_(dt1.itemsize())); list.append(py::int_(dt2.itemsize())); 36712391Sjason@lowepower.com return list; 36812391Sjason@lowepower.com }); 36912391Sjason@lowepower.com struct TrailingPaddingStruct { 37012391Sjason@lowepower.com int32_t a; 37112391Sjason@lowepower.com char b; 37212391Sjason@lowepower.com }; 37312391Sjason@lowepower.com PYBIND11_NUMPY_DTYPE(TrailingPaddingStruct, a, b); 37412391Sjason@lowepower.com m.def("trailing_padding_dtype", []() { return py::dtype::of<TrailingPaddingStruct>(); }); 37512391Sjason@lowepower.com 37612391Sjason@lowepower.com // test_string_array 37712391Sjason@lowepower.com m.def("create_string_array", [](bool non_empty) { 37812391Sjason@lowepower.com py::array_t<StringStruct, 0> arr = mkarray_via_buffer<StringStruct>(non_empty ? 4 : 0); 37912391Sjason@lowepower.com if (non_empty) { 38012391Sjason@lowepower.com auto req = arr.request(); 38112391Sjason@lowepower.com auto ptr = static_cast<StringStruct*>(req.ptr); 38212391Sjason@lowepower.com for (ssize_t i = 0; i < req.size * req.itemsize; i++) 38312391Sjason@lowepower.com static_cast<char*>(req.ptr)[i] = 0; 38412391Sjason@lowepower.com ptr[1].a[0] = 'a'; ptr[1].b[0] = 'a'; 38512391Sjason@lowepower.com ptr[2].a[0] = 'a'; ptr[2].b[0] = 'a'; 38612391Sjason@lowepower.com ptr[3].a[0] = 'a'; ptr[3].b[0] = 'a'; 38712391Sjason@lowepower.com 38812391Sjason@lowepower.com ptr[2].a[1] = 'b'; ptr[2].b[1] = 'b'; 38912391Sjason@lowepower.com ptr[3].a[1] = 'b'; ptr[3].b[1] = 'b'; 39012391Sjason@lowepower.com 39112391Sjason@lowepower.com ptr[3].a[2] = 'c'; ptr[3].b[2] = 'c'; 39212391Sjason@lowepower.com } 39312391Sjason@lowepower.com return arr; 39412391Sjason@lowepower.com }); 39511986Sandreas.sandberg@arm.com m.def("print_string_array", &print_recarray<StringStruct>); 39612391Sjason@lowepower.com 39712391Sjason@lowepower.com // test_array_array 39812391Sjason@lowepower.com m.def("create_array_array", [](size_t n) { 39912391Sjason@lowepower.com py::array_t<ArrayStruct, 0> arr = mkarray_via_buffer<ArrayStruct>(n); 40012391Sjason@lowepower.com auto ptr = (ArrayStruct *) arr.mutable_data(); 40112391Sjason@lowepower.com for (size_t i = 0; i < n; i++) { 40212391Sjason@lowepower.com for (size_t j = 0; j < 3; j++) 40312391Sjason@lowepower.com for (size_t k = 0; k < 4; k++) 40412391Sjason@lowepower.com ptr[i].a[j][k] = char('A' + (i * 100 + j * 10 + k) % 26); 40512391Sjason@lowepower.com for (size_t j = 0; j < 2; j++) 40612391Sjason@lowepower.com ptr[i].b[j] = int32_t(i * 1000 + j); 40712391Sjason@lowepower.com for (size_t j = 0; j < 3; j++) 40812391Sjason@lowepower.com ptr[i].c[j] = uint8_t(i * 10 + j); 40912391Sjason@lowepower.com for (size_t j = 0; j < 4; j++) 41012391Sjason@lowepower.com for (size_t k = 0; k < 2; k++) 41112391Sjason@lowepower.com ptr[i].d[j][k] = float(i) * 100.0f + float(j) * 10.0f + float(k); 41212391Sjason@lowepower.com } 41312391Sjason@lowepower.com return arr; 41412391Sjason@lowepower.com }); 41512391Sjason@lowepower.com m.def("print_array_array", &print_recarray<ArrayStruct>); 41612391Sjason@lowepower.com 41712391Sjason@lowepower.com // test_enum_array 41812391Sjason@lowepower.com m.def("create_enum_array", [](size_t n) { 41912391Sjason@lowepower.com py::array_t<EnumStruct, 0> arr = mkarray_via_buffer<EnumStruct>(n); 42012391Sjason@lowepower.com auto ptr = (EnumStruct *) arr.mutable_data(); 42112391Sjason@lowepower.com for (size_t i = 0; i < n; i++) { 42212391Sjason@lowepower.com ptr[i].e1 = static_cast<E1>(-1 + ((int) i % 2) * 2); 42312391Sjason@lowepower.com ptr[i].e2 = static_cast<E2>(1 + (i % 2)); 42412391Sjason@lowepower.com } 42512391Sjason@lowepower.com return arr; 42612391Sjason@lowepower.com }); 42711986Sandreas.sandberg@arm.com m.def("print_enum_array", &print_recarray<EnumStruct>); 42812391Sjason@lowepower.com 42912391Sjason@lowepower.com // test_complex_array 43012391Sjason@lowepower.com m.def("create_complex_array", [](size_t n) { 43112391Sjason@lowepower.com py::array_t<ComplexStruct, 0> arr = mkarray_via_buffer<ComplexStruct>(n); 43212391Sjason@lowepower.com auto ptr = (ComplexStruct *) arr.mutable_data(); 43312391Sjason@lowepower.com for (size_t i = 0; i < n; i++) { 43412391Sjason@lowepower.com ptr[i].cflt.real(float(i)); 43512391Sjason@lowepower.com ptr[i].cflt.imag(float(i) + 0.25f); 43612391Sjason@lowepower.com ptr[i].cdbl.real(double(i) + 0.5); 43712391Sjason@lowepower.com ptr[i].cdbl.imag(double(i) + 0.75); 43812391Sjason@lowepower.com } 43912391Sjason@lowepower.com return arr; 44012391Sjason@lowepower.com }); 44112391Sjason@lowepower.com m.def("print_complex_array", &print_recarray<ComplexStruct>); 44212391Sjason@lowepower.com 44312391Sjason@lowepower.com // test_array_constructors 44411986Sandreas.sandberg@arm.com m.def("test_array_ctors", &test_array_ctors); 44512391Sjason@lowepower.com 44612391Sjason@lowepower.com // test_compare_buffer_info 44712391Sjason@lowepower.com struct CompareStruct { 44812391Sjason@lowepower.com bool x; 44912391Sjason@lowepower.com uint32_t y; 45012391Sjason@lowepower.com float z; 45112391Sjason@lowepower.com }; 45212391Sjason@lowepower.com PYBIND11_NUMPY_DTYPE(CompareStruct, x, y, z); 45312391Sjason@lowepower.com m.def("compare_buffer_info", []() { 45412391Sjason@lowepower.com py::list list; 45512391Sjason@lowepower.com list.append(py::bool_(py::detail::compare_buffer_info<float>::compare(py::buffer_info(nullptr, sizeof(float), "f", 1)))); 45612391Sjason@lowepower.com list.append(py::bool_(py::detail::compare_buffer_info<unsigned>::compare(py::buffer_info(nullptr, sizeof(int), "I", 1)))); 45712391Sjason@lowepower.com list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), "l", 1)))); 45812391Sjason@lowepower.com list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), sizeof(long) == sizeof(int) ? "i" : "q", 1)))); 45912391Sjason@lowepower.com list.append(py::bool_(py::detail::compare_buffer_info<CompareStruct>::compare(py::buffer_info(nullptr, sizeof(CompareStruct), "T{?:x:3xI:y:f:z:}", 1)))); 46012391Sjason@lowepower.com return list; 46112391Sjason@lowepower.com }); 46212391Sjason@lowepower.com m.def("buffer_to_dtype", [](py::buffer& buf) { return py::dtype(buf.request()); }); 46312391Sjason@lowepower.com 46412391Sjason@lowepower.com // test_scalar_conversion 46512037Sandreas.sandberg@arm.com m.def("f_simple", [](SimpleStruct s) { return s.uint_ * 10; }); 46612037Sandreas.sandberg@arm.com m.def("f_packed", [](PackedStruct s) { return s.uint_ * 10; }); 46712037Sandreas.sandberg@arm.com m.def("f_nested", [](NestedStruct s) { return s.a.uint_ * 10; }); 46812391Sjason@lowepower.com 46912391Sjason@lowepower.com // test_register_dtype 47012037Sandreas.sandberg@arm.com m.def("register_dtype", []() { PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_); }); 47114299Sbbruce@ucdavis.edu 47214299Sbbruce@ucdavis.edu // test_str_leak 47314299Sbbruce@ucdavis.edu m.def("dtype_wrapper", [](py::object d) { return py::dtype::from_args(std::move(d)); }); 47412391Sjason@lowepower.com} 475