Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 1 | /* |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 2 | tests/test_numpy_dtypes.cpp -- Structured and compound NumPy dtypes |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 3 | |
| 4 | Copyright (c) 2016 Ivan Smirnov |
| 5 | |
| 6 | All rights reserved. Use of this source code is governed by a |
| 7 | BSD-style license that can be found in the LICENSE file. |
| 8 | */ |
| 9 | |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 10 | #include "pybind11_tests.h" |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 11 | #include <pybind11/numpy.h> |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 12 | |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 13 | #ifdef __GNUC__ |
| 14 | #define PYBIND11_PACKED(cls) cls __attribute__((__packed__)) |
| 15 | #else |
| 16 | #define PYBIND11_PACKED(cls) __pragma(pack(push, 1)) cls __pragma(pack(pop)) |
| 17 | #endif |
| 18 | |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 19 | namespace py = pybind11; |
| 20 | |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 21 | struct SimpleStruct { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 22 | bool bool_; |
| 23 | uint32_t uint_; |
| 24 | float float_; |
| 25 | long double ldbl_; |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 26 | }; |
| 27 | |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 28 | std::ostream& operator<<(std::ostream& os, const SimpleStruct& v) { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 29 | return os << "s:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_; |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 30 | } |
| 31 | |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 32 | PYBIND11_PACKED(struct PackedStruct { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 33 | bool bool_; |
| 34 | uint32_t uint_; |
| 35 | float float_; |
| 36 | long double ldbl_; |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 37 | }); |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 38 | |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 39 | std::ostream& operator<<(std::ostream& os, const PackedStruct& v) { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 40 | return os << "p:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_; |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 41 | } |
| 42 | |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 43 | PYBIND11_PACKED(struct NestedStruct { |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 44 | SimpleStruct a; |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 45 | PackedStruct b; |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 46 | }); |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 47 | |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 48 | std::ostream& operator<<(std::ostream& os, const NestedStruct& v) { |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 49 | return os << "n:a=" << v.a << ";b=" << v.b; |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 50 | } |
| 51 | |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 52 | struct PartialStruct { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 53 | bool bool_; |
| 54 | uint32_t uint_; |
| 55 | float float_; |
Ivan Smirnov | 245f77b | 2016-08-13 13:20:36 +0100 | [diff] [blame] | 56 | uint64_t dummy2; |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 57 | long double ldbl_; |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 58 | }; |
| 59 | |
| 60 | struct PartialNestedStruct { |
Ivan Smirnov | 245f77b | 2016-08-13 13:20:36 +0100 | [diff] [blame] | 61 | uint64_t dummy1; |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 62 | PartialStruct a; |
Ivan Smirnov | 245f77b | 2016-08-13 13:20:36 +0100 | [diff] [blame] | 63 | uint64_t dummy2; |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 64 | }; |
| 65 | |
Ivan Smirnov | d0bafd9 | 2016-06-26 16:35:28 +0100 | [diff] [blame] | 66 | struct UnboundStruct { }; |
| 67 | |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 68 | struct StringStruct { |
| 69 | char a[3]; |
| 70 | std::array<char, 3> b; |
| 71 | }; |
| 72 | |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 73 | struct ComplexStruct { |
| 74 | std::complex<float> cflt; |
| 75 | std::complex<double> cdbl; |
| 76 | }; |
| 77 | |
| 78 | std::ostream& operator<<(std::ostream& os, const ComplexStruct& v) { |
| 79 | return os << "c:" << v.cflt << "," << v.cdbl; |
| 80 | } |
| 81 | |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 82 | struct ArrayStruct { |
| 83 | char a[3][4]; |
| 84 | int32_t b[2]; |
| 85 | std::array<uint8_t, 3> c; |
| 86 | std::array<float, 2> d[4]; |
| 87 | }; |
| 88 | |
Ivan Smirnov | abd3429 | 2016-11-01 13:29:32 +0000 | [diff] [blame] | 89 | PYBIND11_PACKED(struct StructWithUglyNames { |
| 90 | int8_t __x__; |
| 91 | uint64_t __y__; |
| 92 | }); |
| 93 | |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 94 | enum class E1 : int64_t { A = -1, B = 1 }; |
| 95 | enum E2 : uint8_t { X = 1, Y = 2 }; |
| 96 | |
| 97 | PYBIND11_PACKED(struct EnumStruct { |
| 98 | E1 e1; |
| 99 | E2 e2; |
| 100 | }); |
| 101 | |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 102 | std::ostream& operator<<(std::ostream& os, const StringStruct& v) { |
| 103 | os << "a='"; |
| 104 | for (size_t i = 0; i < 3 && v.a[i]; i++) os << v.a[i]; |
| 105 | os << "',b='"; |
| 106 | for (size_t i = 0; i < 3 && v.b[i]; i++) os << v.b[i]; |
| 107 | return os << "'"; |
| 108 | } |
| 109 | |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 110 | std::ostream& operator<<(std::ostream& os, const ArrayStruct& v) { |
| 111 | os << "a={"; |
| 112 | for (int i = 0; i < 3; i++) { |
| 113 | if (i > 0) |
| 114 | os << ','; |
| 115 | os << '{'; |
| 116 | for (int j = 0; j < 3; j++) |
| 117 | os << v.a[i][j] << ','; |
| 118 | os << v.a[i][3] << '}'; |
| 119 | } |
| 120 | os << "},b={" << v.b[0] << ',' << v.b[1]; |
| 121 | os << "},c={" << int(v.c[0]) << ',' << int(v.c[1]) << ',' << int(v.c[2]); |
| 122 | os << "},d={"; |
| 123 | for (int i = 0; i < 4; i++) { |
| 124 | if (i > 0) |
| 125 | os << ','; |
| 126 | os << '{' << v.d[i][0] << ',' << v.d[i][1] << '}'; |
| 127 | } |
| 128 | return os << '}'; |
| 129 | } |
| 130 | |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 131 | std::ostream& operator<<(std::ostream& os, const EnumStruct& v) { |
| 132 | return os << "e1=" << (v.e1 == E1::A ? "A" : "B") << ",e2=" << (v.e2 == E2::X ? "X" : "Y"); |
| 133 | } |
| 134 | |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 135 | template <typename T> |
| 136 | py::array mkarray_via_buffer(size_t n) { |
| 137 | return py::array(py::buffer_info(nullptr, sizeof(T), |
Ivan Smirnov | 5e71e17 | 2016-06-26 12:42:34 +0100 | [diff] [blame] | 138 | py::format_descriptor<T>::format(), |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 139 | 1, { n }, { sizeof(T) })); |
| 140 | } |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 141 | |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 142 | #define SET_TEST_VALS(s, i) do { \ |
| 143 | s.bool_ = (i) % 2 != 0; \ |
| 144 | s.uint_ = (uint32_t) (i); \ |
| 145 | s.float_ = (float) (i) * 1.5f; \ |
| 146 | s.ldbl_ = (long double) (i) * -2.5L; } while (0) |
| 147 | |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 148 | template <typename S> |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 149 | py::array_t<S, 0> create_recarray(size_t n) { |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 150 | auto arr = mkarray_via_buffer<S>(n); |
Ivan Smirnov | b51fa02 | 2016-07-18 22:35:50 +0100 | [diff] [blame] | 151 | auto req = arr.request(); |
| 152 | auto ptr = static_cast<S*>(req.ptr); |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 153 | for (size_t i = 0; i < n; i++) { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 154 | SET_TEST_VALS(ptr[i], i); |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 155 | } |
| 156 | return arr; |
| 157 | } |
| 158 | |
Ivan Smirnov | d0bafd9 | 2016-06-26 16:35:28 +0100 | [diff] [blame] | 159 | std::string get_format_unbound() { |
| 160 | return py::format_descriptor<UnboundStruct>::format(); |
| 161 | } |
| 162 | |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 163 | py::array_t<NestedStruct, 0> create_nested(size_t n) { |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 164 | auto arr = mkarray_via_buffer<NestedStruct>(n); |
Ivan Smirnov | b51fa02 | 2016-07-18 22:35:50 +0100 | [diff] [blame] | 165 | auto req = arr.request(); |
| 166 | auto ptr = static_cast<NestedStruct*>(req.ptr); |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 167 | for (size_t i = 0; i < n; i++) { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 168 | SET_TEST_VALS(ptr[i].a, i); |
| 169 | SET_TEST_VALS(ptr[i].b, i + 1); |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 170 | } |
| 171 | return arr; |
Ivan Smirnov | bdc9902 | 2016-06-19 16:54:07 +0100 | [diff] [blame] | 172 | } |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 173 | |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 174 | py::array_t<PartialNestedStruct, 0> create_partial_nested(size_t n) { |
| 175 | auto arr = mkarray_via_buffer<PartialNestedStruct>(n); |
Ivan Smirnov | b51fa02 | 2016-07-18 22:35:50 +0100 | [diff] [blame] | 176 | auto req = arr.request(); |
| 177 | auto ptr = static_cast<PartialNestedStruct*>(req.ptr); |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 178 | for (size_t i = 0; i < n; i++) { |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 179 | SET_TEST_VALS(ptr[i].a, i); |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 180 | } |
| 181 | return arr; |
| 182 | } |
| 183 | |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 184 | py::array_t<StringStruct, 0> create_string_array(bool non_empty) { |
| 185 | auto arr = mkarray_via_buffer<StringStruct>(non_empty ? 4 : 0); |
| 186 | if (non_empty) { |
| 187 | auto req = arr.request(); |
| 188 | auto ptr = static_cast<StringStruct*>(req.ptr); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 189 | for (ssize_t i = 0; i < req.size * req.itemsize; i++) |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 190 | static_cast<char*>(req.ptr)[i] = 0; |
| 191 | ptr[1].a[0] = 'a'; ptr[1].b[0] = 'a'; |
| 192 | ptr[2].a[0] = 'a'; ptr[2].b[0] = 'a'; |
| 193 | ptr[3].a[0] = 'a'; ptr[3].b[0] = 'a'; |
| 194 | |
| 195 | ptr[2].a[1] = 'b'; ptr[2].b[1] = 'b'; |
| 196 | ptr[3].a[1] = 'b'; ptr[3].b[1] = 'b'; |
| 197 | |
| 198 | ptr[3].a[2] = 'c'; ptr[3].b[2] = 'c'; |
| 199 | } |
| 200 | return arr; |
| 201 | } |
| 202 | |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 203 | py::array_t<ArrayStruct, 0> create_array_array(size_t n) { |
| 204 | auto arr = mkarray_via_buffer<ArrayStruct>(n); |
| 205 | auto ptr = (ArrayStruct *) arr.mutable_data(); |
| 206 | for (size_t i = 0; i < n; i++) { |
| 207 | for (size_t j = 0; j < 3; j++) |
| 208 | for (size_t k = 0; k < 4; k++) |
| 209 | ptr[i].a[j][k] = char('A' + (i * 100 + j * 10 + k) % 26); |
| 210 | for (size_t j = 0; j < 2; j++) |
| 211 | ptr[i].b[j] = int32_t(i * 1000 + j); |
| 212 | for (size_t j = 0; j < 3; j++) |
| 213 | ptr[i].c[j] = uint8_t(i * 10 + j); |
| 214 | for (size_t j = 0; j < 4; j++) |
| 215 | for (size_t k = 0; k < 2; k++) |
| 216 | ptr[i].d[j][k] = float(i) * 100.0f + float(j) * 10.0f + float(k); |
| 217 | } |
| 218 | return arr; |
| 219 | } |
| 220 | |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 221 | py::array_t<EnumStruct, 0> create_enum_array(size_t n) { |
| 222 | auto arr = mkarray_via_buffer<EnumStruct>(n); |
| 223 | auto ptr = (EnumStruct *) arr.mutable_data(); |
| 224 | for (size_t i = 0; i < n; i++) { |
| 225 | ptr[i].e1 = static_cast<E1>(-1 + ((int) i % 2) * 2); |
| 226 | ptr[i].e2 = static_cast<E2>(1 + (i % 2)); |
| 227 | } |
| 228 | return arr; |
| 229 | } |
| 230 | |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 231 | py::array_t<ComplexStruct, 0> create_complex_array(size_t n) { |
| 232 | auto arr = mkarray_via_buffer<ComplexStruct>(n); |
| 233 | auto ptr = (ComplexStruct *) arr.mutable_data(); |
| 234 | for (size_t i = 0; i < n; i++) { |
| 235 | ptr[i].cflt.real(float(i)); |
| 236 | ptr[i].cflt.imag(float(i) + 0.25f); |
| 237 | ptr[i].cdbl.real(double(i) + 0.5); |
| 238 | ptr[i].cdbl.imag(double(i) + 0.75); |
| 239 | } |
| 240 | return arr; |
| 241 | } |
| 242 | |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 243 | template <typename S> |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 244 | py::list print_recarray(py::array_t<S, 0> arr) { |
| 245 | const auto req = arr.request(); |
| 246 | const auto ptr = static_cast<S*>(req.ptr); |
| 247 | auto l = py::list(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 248 | for (ssize_t i = 0; i < req.size; i++) { |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 249 | std::stringstream ss; |
| 250 | ss << ptr[i]; |
| 251 | l.append(py::str(ss.str())); |
| 252 | } |
| 253 | return l; |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 254 | } |
Ivan Smirnov | bdc9902 | 2016-06-19 16:54:07 +0100 | [diff] [blame] | 255 | |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 256 | py::list print_format_descriptors() { |
| 257 | const auto fmts = { |
| 258 | py::format_descriptor<SimpleStruct>::format(), |
| 259 | py::format_descriptor<PackedStruct>::format(), |
| 260 | py::format_descriptor<NestedStruct>::format(), |
| 261 | py::format_descriptor<PartialStruct>::format(), |
| 262 | py::format_descriptor<PartialNestedStruct>::format(), |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 263 | py::format_descriptor<StringStruct>::format(), |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 264 | py::format_descriptor<ArrayStruct>::format(), |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 265 | py::format_descriptor<EnumStruct>::format(), |
| 266 | py::format_descriptor<ComplexStruct>::format() |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 267 | }; |
| 268 | auto l = py::list(); |
| 269 | for (const auto &fmt : fmts) { |
| 270 | l.append(py::cast(fmt)); |
| 271 | } |
| 272 | return l; |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 273 | } |
| 274 | |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 275 | py::list print_dtypes() { |
| 276 | const auto dtypes = { |
Dean Moldovan | e18bc02 | 2016-10-25 22:12:39 +0200 | [diff] [blame] | 277 | py::str(py::dtype::of<SimpleStruct>()), |
| 278 | py::str(py::dtype::of<PackedStruct>()), |
| 279 | py::str(py::dtype::of<NestedStruct>()), |
| 280 | py::str(py::dtype::of<PartialStruct>()), |
| 281 | py::str(py::dtype::of<PartialNestedStruct>()), |
| 282 | py::str(py::dtype::of<StringStruct>()), |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 283 | py::str(py::dtype::of<ArrayStruct>()), |
Dean Moldovan | e18bc02 | 2016-10-25 22:12:39 +0200 | [diff] [blame] | 284 | py::str(py::dtype::of<EnumStruct>()), |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 285 | py::str(py::dtype::of<StructWithUglyNames>()), |
| 286 | py::str(py::dtype::of<ComplexStruct>()) |
Dean Moldovan | 665e880 | 2016-08-12 22:28:31 +0200 | [diff] [blame] | 287 | }; |
| 288 | auto l = py::list(); |
| 289 | for (const auto &s : dtypes) { |
| 290 | l.append(s); |
| 291 | } |
| 292 | return l; |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 293 | } |
| 294 | |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 295 | py::array_t<int32_t, 0> test_array_ctors(int i) { |
| 296 | using arr_t = py::array_t<int32_t, 0>; |
| 297 | |
| 298 | std::vector<int32_t> data { 1, 2, 3, 4, 5, 6 }; |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 299 | std::vector<ssize_t> shape { 3, 2 }; |
Cris Luengo | d400f60 | 2017-04-05 16:13:04 -0600 | [diff] [blame] | 300 | std::vector<ssize_t> strides { 8, 4 }; |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 301 | |
| 302 | auto ptr = data.data(); |
| 303 | auto vptr = (void *) ptr; |
| 304 | auto dtype = py::dtype("int32"); |
| 305 | |
| 306 | py::buffer_info buf_ndim1(vptr, 4, "i", 6); |
Ivan Smirnov | c6257f8 | 2016-07-25 00:46:39 +0100 | [diff] [blame] | 307 | py::buffer_info buf_ndim1_null(nullptr, 4, "i", 6); |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 308 | py::buffer_info buf_ndim2(vptr, 4, "i", 2, shape, strides); |
Ivan Smirnov | c6257f8 | 2016-07-25 00:46:39 +0100 | [diff] [blame] | 309 | py::buffer_info buf_ndim2_null(nullptr, 4, "i", 2, shape, strides); |
| 310 | |
| 311 | auto fill = [](py::array arr) { |
| 312 | auto req = arr.request(); |
| 313 | for (int i = 0; i < 6; i++) ((int32_t *) req.ptr)[i] = i + 1; |
| 314 | return arr; |
| 315 | }; |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 316 | |
| 317 | switch (i) { |
| 318 | // shape: (3, 2) |
Ivan Smirnov | c6257f8 | 2016-07-25 00:46:39 +0100 | [diff] [blame] | 319 | case 10: return arr_t(shape, strides, ptr); |
| 320 | case 11: return py::array(shape, strides, ptr); |
| 321 | case 12: return py::array(dtype, shape, strides, vptr); |
| 322 | case 13: return arr_t(shape, ptr); |
| 323 | case 14: return py::array(shape, ptr); |
| 324 | case 15: return py::array(dtype, shape, vptr); |
| 325 | case 16: return arr_t(buf_ndim2); |
| 326 | case 17: return py::array(buf_ndim2); |
| 327 | // shape: (3, 2) - post-fill |
| 328 | case 20: return fill(arr_t(shape, strides)); |
| 329 | case 21: return py::array(shape, strides, ptr); // can't have nullptr due to templated ctor |
| 330 | case 22: return fill(py::array(dtype, shape, strides)); |
| 331 | case 23: return fill(arr_t(shape)); |
| 332 | case 24: return py::array(shape, ptr); // can't have nullptr due to templated ctor |
| 333 | case 25: return fill(py::array(dtype, shape)); |
| 334 | case 26: return fill(arr_t(buf_ndim2_null)); |
| 335 | case 27: return fill(py::array(buf_ndim2_null)); |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 336 | // shape: (6, ) |
Ivan Smirnov | c6257f8 | 2016-07-25 00:46:39 +0100 | [diff] [blame] | 337 | case 30: return arr_t(6, ptr); |
| 338 | case 31: return py::array(6, ptr); |
| 339 | case 32: return py::array(dtype, 6, vptr); |
| 340 | case 33: return arr_t(buf_ndim1); |
| 341 | case 34: return py::array(buf_ndim1); |
| 342 | // shape: (6, ) |
| 343 | case 40: return fill(arr_t(6)); |
| 344 | case 41: return py::array(6, ptr); // can't have nullptr due to templated ctor |
| 345 | case 42: return fill(py::array(dtype, 6)); |
| 346 | case 43: return fill(arr_t(buf_ndim1_null)); |
| 347 | case 44: return fill(py::array(buf_ndim1_null)); |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 348 | } |
| 349 | return arr_t(); |
| 350 | } |
| 351 | |
Ivan Smirnov | 611e614 | 2016-07-24 23:52:42 +0100 | [diff] [blame] | 352 | py::list test_dtype_ctors() { |
| 353 | py::list list; |
| 354 | list.append(py::dtype("int32")); |
| 355 | list.append(py::dtype(std::string("float64"))); |
| 356 | list.append(py::dtype::from_args(py::str("bool"))); |
| 357 | py::list names, offsets, formats; |
| 358 | py::dict dict; |
| 359 | names.append(py::str("a")); names.append(py::str("b")); dict["names"] = names; |
| 360 | offsets.append(py::int_(1)); offsets.append(py::int_(10)); dict["offsets"] = offsets; |
| 361 | formats.append(py::dtype("int32")); formats.append(py::dtype("float64")); dict["formats"] = formats; |
| 362 | dict["itemsize"] = py::int_(20); |
| 363 | list.append(py::dtype::from_args(dict)); |
| 364 | list.append(py::dtype(names, formats, offsets, 20)); |
Patrick Stewart | 5271576 | 2016-11-22 14:56:52 +0000 | [diff] [blame] | 365 | list.append(py::dtype(py::buffer_info((void *) 0, sizeof(unsigned int), "I", 1))); |
| 366 | list.append(py::dtype(py::buffer_info((void *) 0, 0, "T{i:a:f:b:}", 1))); |
Ivan Smirnov | 611e614 | 2016-07-24 23:52:42 +0100 | [diff] [blame] | 367 | return list; |
| 368 | } |
| 369 | |
Patrick Stewart | 5271576 | 2016-11-22 14:56:52 +0000 | [diff] [blame] | 370 | struct TrailingPaddingStruct { |
| 371 | int32_t a; |
| 372 | char b; |
| 373 | }; |
| 374 | |
| 375 | py::dtype trailing_padding_dtype() { |
| 376 | return py::dtype::of<TrailingPaddingStruct>(); |
| 377 | } |
| 378 | |
| 379 | py::dtype buffer_to_dtype(py::buffer& buf) { |
| 380 | return py::dtype(buf.request()); |
| 381 | } |
| 382 | |
Ivan Smirnov | 10af58f | 2016-07-25 00:15:07 +0100 | [diff] [blame] | 383 | py::list test_dtype_methods() { |
| 384 | py::list list; |
| 385 | auto dt1 = py::dtype::of<int32_t>(); |
| 386 | auto dt2 = py::dtype::of<SimpleStruct>(); |
| 387 | list.append(dt1); list.append(dt2); |
| 388 | list.append(py::bool_(dt1.has_fields())); list.append(py::bool_(dt2.has_fields())); |
| 389 | list.append(py::int_(dt1.itemsize())); list.append(py::int_(dt2.itemsize())); |
| 390 | return list; |
Ivan Smirnov | 611e614 | 2016-07-24 23:52:42 +0100 | [diff] [blame] | 391 | } |
| 392 | |
Patrick Stewart | 0b6d08a | 2016-11-21 17:40:43 +0000 | [diff] [blame] | 393 | struct CompareStruct { |
| 394 | bool x; |
| 395 | uint32_t y; |
| 396 | float z; |
| 397 | }; |
| 398 | |
| 399 | py::list test_compare_buffer_info() { |
| 400 | py::list list; |
| 401 | list.append(py::bool_(py::detail::compare_buffer_info<float>::compare(py::buffer_info(nullptr, sizeof(float), "f", 1)))); |
| 402 | list.append(py::bool_(py::detail::compare_buffer_info<unsigned>::compare(py::buffer_info(nullptr, sizeof(int), "I", 1)))); |
| 403 | list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), "l", 1)))); |
| 404 | list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), sizeof(long) == sizeof(int) ? "i" : "q", 1)))); |
| 405 | list.append(py::bool_(py::detail::compare_buffer_info<CompareStruct>::compare(py::buffer_info(nullptr, sizeof(CompareStruct), "T{?:x:3xI:y:f:z:}", 1)))); |
| 406 | return list; |
| 407 | } |
| 408 | |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 409 | test_initializer numpy_dtypes([](py::module &m) { |
Dean Moldovan | 2391917 | 2016-08-25 17:08:09 +0200 | [diff] [blame] | 410 | try { |
| 411 | py::module::import("numpy"); |
| 412 | } catch (...) { |
| 413 | return; |
| 414 | } |
| 415 | |
Ivan Smirnov | cbbb783 | 2016-10-20 16:47:29 +0100 | [diff] [blame] | 416 | // typeinfo may be registered before the dtype descriptor for scalar casts to work... |
| 417 | py::class_<SimpleStruct>(m, "SimpleStruct"); |
| 418 | |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 419 | PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_); |
| 420 | PYBIND11_NUMPY_DTYPE(PackedStruct, bool_, uint_, float_, ldbl_); |
Ivan Smirnov | 5412a05 | 2016-07-02 16:18:42 +0100 | [diff] [blame] | 421 | PYBIND11_NUMPY_DTYPE(NestedStruct, a, b); |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 422 | PYBIND11_NUMPY_DTYPE(PartialStruct, bool_, uint_, float_, ldbl_); |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 423 | PYBIND11_NUMPY_DTYPE(PartialNestedStruct, a); |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 424 | PYBIND11_NUMPY_DTYPE(StringStruct, a, b); |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 425 | PYBIND11_NUMPY_DTYPE(ArrayStruct, a, b, c, d); |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 426 | PYBIND11_NUMPY_DTYPE(EnumStruct, e1, e2); |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 427 | PYBIND11_NUMPY_DTYPE(ComplexStruct, cflt, cdbl); |
Patrick Stewart | 5271576 | 2016-11-22 14:56:52 +0000 | [diff] [blame] | 428 | PYBIND11_NUMPY_DTYPE(TrailingPaddingStruct, a, b); |
Patrick Stewart | 0b6d08a | 2016-11-21 17:40:43 +0000 | [diff] [blame] | 429 | PYBIND11_NUMPY_DTYPE(CompareStruct, x, y, z); |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 430 | |
Ivan Smirnov | a6e6a8b | 2016-10-23 15:27:13 +0100 | [diff] [blame] | 431 | // ... or after |
Ivan Smirnov | cbbb783 | 2016-10-20 16:47:29 +0100 | [diff] [blame] | 432 | py::class_<PackedStruct>(m, "PackedStruct"); |
| 433 | |
Ivan Smirnov | abd3429 | 2016-11-01 13:29:32 +0000 | [diff] [blame] | 434 | PYBIND11_NUMPY_DTYPE_EX(StructWithUglyNames, __x__, "x", __y__, "y"); |
| 435 | |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 436 | // If uncommented, this should produce a static_assert failure telling the user that the struct |
| 437 | // is not a POD type |
| 438 | // struct NotPOD { std::string v; NotPOD() : v("hi") {}; }; |
| 439 | // PYBIND11_NUMPY_DTYPE(NotPOD, v); |
| 440 | |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 441 | m.def("create_rec_simple", &create_recarray<SimpleStruct>); |
Ivan Smirnov | bb4015d | 2016-06-19 15:50:31 +0100 | [diff] [blame] | 442 | m.def("create_rec_packed", &create_recarray<PackedStruct>); |
Ivan Smirnov | 7f913ae | 2016-06-19 16:41:15 +0100 | [diff] [blame] | 443 | m.def("create_rec_nested", &create_nested); |
Ivan Smirnov | 8fa09cb | 2016-07-06 00:28:12 +0100 | [diff] [blame] | 444 | m.def("create_rec_partial", &create_recarray<PartialStruct>); |
| 445 | m.def("create_rec_partial_nested", &create_partial_nested); |
Ivan Smirnov | bdc9902 | 2016-06-19 16:54:07 +0100 | [diff] [blame] | 446 | m.def("print_format_descriptors", &print_format_descriptors); |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 447 | m.def("print_rec_simple", &print_recarray<SimpleStruct>); |
Ivan Smirnov | 669e142 | 2016-06-21 21:05:29 +0100 | [diff] [blame] | 448 | m.def("print_rec_packed", &print_recarray<PackedStruct>); |
| 449 | m.def("print_rec_nested", &print_recarray<NestedStruct>); |
Ivan Smirnov | 4f16421 | 2016-06-22 01:07:20 +0100 | [diff] [blame] | 450 | m.def("print_dtypes", &print_dtypes); |
Ivan Smirnov | d0bafd9 | 2016-06-26 16:35:28 +0100 | [diff] [blame] | 451 | m.def("get_format_unbound", &get_format_unbound); |
Ivan Smirnov | f9c0def | 2016-07-20 00:19:24 +0100 | [diff] [blame] | 452 | m.def("create_string_array", &create_string_array); |
| 453 | m.def("print_string_array", &print_recarray<StringStruct>); |
Bruce Merry | 8e0d832 | 2017-05-10 10:21:01 +0200 | [diff] [blame] | 454 | m.def("create_array_array", &create_array_array); |
| 455 | m.def("print_array_array", &print_recarray<ArrayStruct>); |
Ivan Smirnov | 2f3f368 | 2016-10-20 12:28:47 +0100 | [diff] [blame] | 456 | m.def("create_enum_array", &create_enum_array); |
| 457 | m.def("print_enum_array", &print_recarray<EnumStruct>); |
Bruce Merry | b82c0f0 | 2017-05-10 11:36:24 +0200 | [diff] [blame] | 458 | m.def("create_complex_array", &create_complex_array); |
| 459 | m.def("print_complex_array", &print_recarray<ComplexStruct>); |
Ivan Smirnov | e19980c | 2016-07-24 20:30:17 +0100 | [diff] [blame] | 460 | m.def("test_array_ctors", &test_array_ctors); |
Ivan Smirnov | 611e614 | 2016-07-24 23:52:42 +0100 | [diff] [blame] | 461 | m.def("test_dtype_ctors", &test_dtype_ctors); |
| 462 | m.def("test_dtype_methods", &test_dtype_methods); |
Patrick Stewart | 0b6d08a | 2016-11-21 17:40:43 +0000 | [diff] [blame] | 463 | m.def("compare_buffer_info", &test_compare_buffer_info); |
Patrick Stewart | 5271576 | 2016-11-22 14:56:52 +0000 | [diff] [blame] | 464 | m.def("trailing_padding_dtype", &trailing_padding_dtype); |
| 465 | m.def("buffer_to_dtype", &buffer_to_dtype); |
Jason Rhinelander | f7f5bc8 | 2017-01-31 11:00:15 -0500 | [diff] [blame] | 466 | m.def("f_simple", [](SimpleStruct s) { return s.uint_ * 10; }); |
| 467 | m.def("f_packed", [](PackedStruct s) { return s.uint_ * 10; }); |
| 468 | m.def("f_nested", [](NestedStruct s) { return s.a.uint_ * 10; }); |
| 469 | m.def("register_dtype", []() { PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_); }); |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 470 | }); |
Ivan Smirnov | f5f75c6 | 2016-07-18 22:47:40 +0100 | [diff] [blame] | 471 | |
| 472 | #undef PYBIND11_PACKED |