Ivan Smirnov | 91b3d68 | 2016-08-29 02:41:05 +0100 | [diff] [blame] | 1 | /* |
| 2 | tests/test_numpy_array.cpp -- test core array functionality |
| 3 | |
| 4 | Copyright (c) 2016 Ivan Smirnov <i.s.smirnov@gmail.com> |
| 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 | |
| 10 | #include "pybind11_tests.h" |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 11 | |
Ivan Smirnov | 91b3d68 | 2016-08-29 02:41:05 +0100 | [diff] [blame] | 12 | #include <pybind11/numpy.h> |
| 13 | #include <pybind11/stl.h> |
| 14 | |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 15 | #include <cstdint> |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 16 | |
| 17 | using arr = py::array; |
| 18 | using arr_t = py::array_t<uint16_t, 0>; |
Dean Moldovan | 16afbce | 2017-03-13 19:17:18 +0100 | [diff] [blame] | 19 | static_assert(std::is_same<arr_t::value_type, uint16_t>::value, ""); |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 20 | |
Sylvain Corlay | 5027c4f | 2016-11-16 08:53:37 -0800 | [diff] [blame] | 21 | template<typename... Ix> arr data(const arr& a, Ix... index) { |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 22 | return arr(a.nbytes() - a.offset_at(index...), (const uint8_t *) a.data(index...)); |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 23 | } |
| 24 | |
Sylvain Corlay | 5027c4f | 2016-11-16 08:53:37 -0800 | [diff] [blame] | 25 | template<typename... Ix> arr data_t(const arr_t& a, Ix... index) { |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 26 | return arr(a.size() - a.index_at(index...), a.data(index...)); |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 27 | } |
| 28 | |
| 29 | arr& mutate_data(arr& a) { |
| 30 | auto ptr = (uint8_t *) a.mutable_data(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 31 | for (ssize_t i = 0; i < a.nbytes(); i++) |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 32 | ptr[i] = (uint8_t) (ptr[i] * 2); |
| 33 | return a; |
| 34 | } |
| 35 | |
| 36 | arr_t& mutate_data_t(arr_t& a) { |
| 37 | auto ptr = a.mutable_data(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 38 | for (ssize_t i = 0; i < a.size(); i++) |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 39 | ptr[i]++; |
| 40 | return a; |
| 41 | } |
| 42 | |
Sylvain Corlay | 5027c4f | 2016-11-16 08:53:37 -0800 | [diff] [blame] | 43 | template<typename... Ix> arr& mutate_data(arr& a, Ix... index) { |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 44 | auto ptr = (uint8_t *) a.mutable_data(index...); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 45 | for (ssize_t i = 0; i < a.nbytes() - a.offset_at(index...); i++) |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 46 | ptr[i] = (uint8_t) (ptr[i] * 2); |
| 47 | return a; |
| 48 | } |
| 49 | |
Sylvain Corlay | 5027c4f | 2016-11-16 08:53:37 -0800 | [diff] [blame] | 50 | template<typename... Ix> arr_t& mutate_data_t(arr_t& a, Ix... index) { |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 51 | auto ptr = a.mutable_data(index...); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 52 | for (ssize_t i = 0; i < a.size() - a.index_at(index...); i++) |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 53 | ptr[i]++; |
| 54 | return a; |
| 55 | } |
| 56 | |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 57 | template<typename... Ix> ssize_t index_at(const arr& a, Ix... idx) { return a.index_at(idx...); } |
| 58 | template<typename... Ix> ssize_t index_at_t(const arr_t& a, Ix... idx) { return a.index_at(idx...); } |
| 59 | template<typename... Ix> ssize_t offset_at(const arr& a, Ix... idx) { return a.offset_at(idx...); } |
| 60 | template<typename... Ix> ssize_t offset_at_t(const arr_t& a, Ix... idx) { return a.offset_at(idx...); } |
| 61 | template<typename... Ix> ssize_t at_t(const arr_t& a, Ix... idx) { return a.at(idx...); } |
Sylvain Corlay | 5027c4f | 2016-11-16 08:53:37 -0800 | [diff] [blame] | 62 | template<typename... Ix> arr_t& mutate_at_t(arr_t& a, Ix... idx) { a.mutable_at(idx...)++; return a; } |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 63 | |
| 64 | #define def_index_fn(name, type) \ |
| 65 | sm.def(#name, [](type a) { return name(a); }); \ |
| 66 | sm.def(#name, [](type a, int i) { return name(a, i); }); \ |
| 67 | sm.def(#name, [](type a, int i, int j) { return name(a, i, j); }); \ |
| 68 | sm.def(#name, [](type a, int i, int j, int k) { return name(a, i, j, k); }); |
| 69 | |
Jason Rhinelander | 773339f | 2017-03-20 17:48:38 -0300 | [diff] [blame] | 70 | template <typename T, typename T2> py::handle auxiliaries(T &&r, T2 &&r2) { |
| 71 | if (r.ndim() != 2) throw std::domain_error("error: ndim != 2"); |
| 72 | py::list l; |
| 73 | l.append(*r.data(0, 0)); |
| 74 | l.append(*r2.mutable_data(0, 0)); |
| 75 | l.append(r.data(0, 1) == r2.mutable_data(0, 1)); |
| 76 | l.append(r.ndim()); |
| 77 | l.append(r.itemsize()); |
| 78 | l.append(r.shape(0)); |
| 79 | l.append(r.shape(1)); |
| 80 | l.append(r.size()); |
| 81 | l.append(r.nbytes()); |
| 82 | return l.release(); |
| 83 | } |
| 84 | |
Ivan Smirnov | 91b3d68 | 2016-08-29 02:41:05 +0100 | [diff] [blame] | 85 | test_initializer numpy_array([](py::module &m) { |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 86 | auto sm = m.def_submodule("array"); |
| 87 | |
| 88 | sm.def("ndim", [](const arr& a) { return a.ndim(); }); |
| 89 | sm.def("shape", [](const arr& a) { return arr(a.ndim(), a.shape()); }); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 90 | sm.def("shape", [](const arr& a, ssize_t dim) { return a.shape(dim); }); |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 91 | sm.def("strides", [](const arr& a) { return arr(a.ndim(), a.strides()); }); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 92 | sm.def("strides", [](const arr& a, ssize_t dim) { return a.strides(dim); }); |
Ivan Smirnov | aca6bca | 2016-09-08 23:03:35 +0100 | [diff] [blame] | 93 | sm.def("writeable", [](const arr& a) { return a.writeable(); }); |
| 94 | sm.def("size", [](const arr& a) { return a.size(); }); |
| 95 | sm.def("itemsize", [](const arr& a) { return a.itemsize(); }); |
| 96 | sm.def("nbytes", [](const arr& a) { return a.nbytes(); }); |
| 97 | sm.def("owndata", [](const arr& a) { return a.owndata(); }); |
| 98 | |
| 99 | def_index_fn(data, const arr&); |
| 100 | def_index_fn(data_t, const arr_t&); |
| 101 | def_index_fn(index_at, const arr&); |
| 102 | def_index_fn(index_at_t, const arr_t&); |
| 103 | def_index_fn(offset_at, const arr&); |
| 104 | def_index_fn(offset_at_t, const arr_t&); |
| 105 | def_index_fn(mutate_data, arr&); |
| 106 | def_index_fn(mutate_data_t, arr_t&); |
| 107 | def_index_fn(at_t, const arr_t&); |
| 108 | def_index_fn(mutate_at_t, arr_t&); |
Wenzel Jakob | 43f6aa6 | 2016-10-12 23:34:06 +0200 | [diff] [blame] | 109 | |
| 110 | sm.def("make_f_array", [] { |
| 111 | return py::array_t<float>({ 2, 2 }, { 4, 8 }); |
| 112 | }); |
| 113 | |
| 114 | sm.def("make_c_array", [] { |
| 115 | return py::array_t<float>({ 2, 2 }, { 8, 4 }); |
| 116 | }); |
Wenzel Jakob | 369e9b3 | 2016-10-13 00:57:42 +0200 | [diff] [blame] | 117 | |
| 118 | sm.def("wrap", [](py::array a) { |
| 119 | return py::array( |
| 120 | a.dtype(), |
Jason Rhinelander | 5f38386 | 2017-04-07 15:49:54 -0400 | [diff] [blame] | 121 | {a.shape(), a.shape() + a.ndim()}, |
| 122 | {a.strides(), a.strides() + a.ndim()}, |
Wenzel Jakob | 369e9b3 | 2016-10-13 00:57:42 +0200 | [diff] [blame] | 123 | a.data(), |
| 124 | a |
| 125 | ); |
| 126 | }); |
Wenzel Jakob | fac7c09 | 2016-10-13 10:37:52 +0200 | [diff] [blame] | 127 | |
| 128 | struct ArrayClass { |
| 129 | int data[2] = { 1, 2 }; |
| 130 | ArrayClass() { py::print("ArrayClass()"); } |
| 131 | ~ArrayClass() { py::print("~ArrayClass()"); } |
| 132 | }; |
| 133 | |
| 134 | py::class_<ArrayClass>(sm, "ArrayClass") |
| 135 | .def(py::init<>()) |
| 136 | .def("numpy_view", [](py::object &obj) { |
| 137 | py::print("ArrayClass::numpy_view()"); |
| 138 | ArrayClass &a = obj.cast<ArrayClass&>(); |
| 139 | return py::array_t<int>({2}, {4}, a.data, obj); |
| 140 | } |
| 141 | ); |
Wenzel Jakob | 496feac | 2016-10-28 00:37:07 +0200 | [diff] [blame] | 142 | |
Wenzel Jakob | 030d10e | 2016-10-28 01:23:42 +0200 | [diff] [blame] | 143 | sm.def("function_taking_uint64", [](uint64_t) { }); |
Dean Moldovan | 4de2710 | 2016-11-16 01:35:22 +0100 | [diff] [blame] | 144 | |
| 145 | sm.def("isinstance_untyped", [](py::object yes, py::object no) { |
| 146 | return py::isinstance<py::array>(yes) && !py::isinstance<py::array>(no); |
| 147 | }); |
| 148 | |
| 149 | sm.def("isinstance_typed", [](py::object o) { |
| 150 | return py::isinstance<py::array_t<double>>(o) && !py::isinstance<py::array_t<int>>(o); |
| 151 | }); |
| 152 | |
| 153 | sm.def("default_constructors", []() { |
| 154 | return py::dict( |
| 155 | "array"_a=py::array(), |
| 156 | "array_t<int32>"_a=py::array_t<std::int32_t>(), |
| 157 | "array_t<double>"_a=py::array_t<double>() |
| 158 | ); |
| 159 | }); |
| 160 | |
| 161 | sm.def("converting_constructors", [](py::object o) { |
| 162 | return py::dict( |
| 163 | "array"_a=py::array(o), |
| 164 | "array_t<int32>"_a=py::array_t<std::int32_t>(o), |
| 165 | "array_t<double>"_a=py::array_t<double>(o) |
| 166 | ); |
| 167 | }); |
Jason Rhinelander | ee2e5a5 | 2017-02-24 05:33:31 -0500 | [diff] [blame] | 168 | |
Jason Rhinelander | c44fe6f | 2017-02-26 18:03:00 -0500 | [diff] [blame] | 169 | // Overload resolution tests: |
| 170 | sm.def("overloaded", [](py::array_t<double>) { return "double"; }); |
| 171 | sm.def("overloaded", [](py::array_t<float>) { return "float"; }); |
| 172 | sm.def("overloaded", [](py::array_t<int>) { return "int"; }); |
| 173 | sm.def("overloaded", [](py::array_t<unsigned short>) { return "unsigned short"; }); |
| 174 | sm.def("overloaded", [](py::array_t<long long>) { return "long long"; }); |
| 175 | sm.def("overloaded", [](py::array_t<std::complex<double>>) { return "double complex"; }); |
| 176 | sm.def("overloaded", [](py::array_t<std::complex<float>>) { return "float complex"; }); |
| 177 | |
| 178 | sm.def("overloaded2", [](py::array_t<std::complex<double>>) { return "double complex"; }); |
| 179 | sm.def("overloaded2", [](py::array_t<double>) { return "double"; }); |
| 180 | sm.def("overloaded2", [](py::array_t<std::complex<float>>) { return "float complex"; }); |
| 181 | sm.def("overloaded2", [](py::array_t<float>) { return "float"; }); |
| 182 | |
| 183 | // Only accept the exact types: |
| 184 | sm.def("overloaded3", [](py::array_t<int>) { return "int"; }, py::arg().noconvert()); |
| 185 | sm.def("overloaded3", [](py::array_t<double>) { return "double"; }, py::arg().noconvert()); |
| 186 | |
| 187 | // Make sure we don't do unsafe coercion (e.g. float to int) when not using forcecast, but |
| 188 | // rather that float gets converted via the safe (conversion to double) overload: |
| 189 | sm.def("overloaded4", [](py::array_t<long long, 0>) { return "long long"; }); |
| 190 | sm.def("overloaded4", [](py::array_t<double, 0>) { return "double"; }); |
| 191 | |
| 192 | // But we do allow conversion to int if forcecast is enabled (but only if no overload matches |
| 193 | // without conversion) |
| 194 | sm.def("overloaded5", [](py::array_t<unsigned int>) { return "unsigned int"; }); |
| 195 | sm.def("overloaded5", [](py::array_t<double>) { return "double"; }); |
| 196 | |
Jason Rhinelander | ee2e5a5 | 2017-02-24 05:33:31 -0500 | [diff] [blame] | 197 | // Issue 685: ndarray shouldn't go to std::string overload |
| 198 | sm.def("issue685", [](std::string) { return "string"; }); |
| 199 | sm.def("issue685", [](py::array) { return "array"; }); |
| 200 | sm.def("issue685", [](py::object) { return "other"; }); |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 201 | |
| 202 | sm.def("proxy_add2", [](py::array_t<double> a, double v) { |
| 203 | auto r = a.mutable_unchecked<2>(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 204 | for (ssize_t i = 0; i < r.shape(0); i++) |
| 205 | for (ssize_t j = 0; j < r.shape(1); j++) |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 206 | r(i, j) += v; |
| 207 | }, py::arg().noconvert(), py::arg()); |
Jason Rhinelander | 773339f | 2017-03-20 17:48:38 -0300 | [diff] [blame] | 208 | |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 209 | sm.def("proxy_init3", [](double start) { |
| 210 | py::array_t<double, py::array::c_style> a({ 3, 3, 3 }); |
| 211 | auto r = a.mutable_unchecked<3>(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 212 | for (ssize_t i = 0; i < r.shape(0); i++) |
| 213 | for (ssize_t j = 0; j < r.shape(1); j++) |
| 214 | for (ssize_t k = 0; k < r.shape(2); k++) |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 215 | r(i, j, k) = start++; |
| 216 | return a; |
| 217 | }); |
| 218 | sm.def("proxy_init3F", [](double start) { |
| 219 | py::array_t<double, py::array::f_style> a({ 3, 3, 3 }); |
| 220 | auto r = a.mutable_unchecked<3>(); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 221 | for (ssize_t k = 0; k < r.shape(2); k++) |
| 222 | for (ssize_t j = 0; j < r.shape(1); j++) |
| 223 | for (ssize_t i = 0; i < r.shape(0); i++) |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 224 | r(i, j, k) = start++; |
| 225 | return a; |
| 226 | }); |
| 227 | sm.def("proxy_squared_L2_norm", [](py::array_t<double> a) { |
| 228 | auto r = a.unchecked<1>(); |
| 229 | double sumsq = 0; |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 230 | for (ssize_t i = 0; i < r.shape(0); i++) |
Jason Rhinelander | 423a49b | 2017-03-19 01:14:23 -0300 | [diff] [blame] | 231 | sumsq += r[i] * r(i); // Either notation works for a 1D array |
| 232 | return sumsq; |
| 233 | }); |
Jason Rhinelander | 773339f | 2017-03-20 17:48:38 -0300 | [diff] [blame] | 234 | |
| 235 | sm.def("proxy_auxiliaries2", [](py::array_t<double> a) { |
| 236 | auto r = a.unchecked<2>(); |
| 237 | auto r2 = a.mutable_unchecked<2>(); |
| 238 | return auxiliaries(r, r2); |
| 239 | }); |
| 240 | |
| 241 | // Same as the above, but without a compile-time dimensions specification: |
| 242 | sm.def("proxy_add2_dyn", [](py::array_t<double> a, double v) { |
| 243 | auto r = a.mutable_unchecked(); |
| 244 | if (r.ndim() != 2) throw std::domain_error("error: ndim != 2"); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 245 | for (ssize_t i = 0; i < r.shape(0); i++) |
| 246 | for (ssize_t j = 0; j < r.shape(1); j++) |
Jason Rhinelander | 773339f | 2017-03-20 17:48:38 -0300 | [diff] [blame] | 247 | r(i, j) += v; |
| 248 | }, py::arg().noconvert(), py::arg()); |
| 249 | sm.def("proxy_init3_dyn", [](double start) { |
| 250 | py::array_t<double, py::array::c_style> a({ 3, 3, 3 }); |
| 251 | auto r = a.mutable_unchecked(); |
| 252 | if (r.ndim() != 3) throw std::domain_error("error: ndim != 3"); |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 253 | for (ssize_t i = 0; i < r.shape(0); i++) |
| 254 | for (ssize_t j = 0; j < r.shape(1); j++) |
| 255 | for (ssize_t k = 0; k < r.shape(2); k++) |
Jason Rhinelander | 773339f | 2017-03-20 17:48:38 -0300 | [diff] [blame] | 256 | r(i, j, k) = start++; |
| 257 | return a; |
| 258 | }); |
| 259 | sm.def("proxy_auxiliaries2_dyn", [](py::array_t<double> a) { |
| 260 | return auxiliaries(a.unchecked(), a.mutable_unchecked()); |
| 261 | }); |
| 262 | |
| 263 | sm.def("array_auxiliaries2", [](py::array_t<double> a) { |
| 264 | return auxiliaries(a, a); |
| 265 | }); |
Jason Rhinelander | 5749b50 | 2017-04-10 11:05:26 -0400 | [diff] [blame] | 266 | |
| 267 | // Issue #785: Uninformative "Unknown internal error" exception when constructing array from empty object: |
| 268 | sm.def("array_fail_test", []() { return py::array(py::object()); }); |
| 269 | sm.def("array_t_fail_test", []() { return py::array_t<double>(py::object()); }); |
Jason Rhinelander | 51d18aa | 2017-04-28 11:06:16 -0400 | [diff] [blame] | 270 | |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 271 | // Make sure the error from numpy is being passed through: |
| 272 | sm.def("array_fail_test_negative_size", []() { int c = 0; return py::array(-1, &c); }); |
| 273 | |
Jason Rhinelander | 51d18aa | 2017-04-28 11:06:16 -0400 | [diff] [blame] | 274 | // Issue (unnumbered; reported in #788): regression: initializer lists can be ambiguous |
| 275 | sm.def("array_initializer_list", []() { return py::array_t<float>(1); }); // { 1 } also works, but clang warns about it |
| 276 | sm.def("array_initializer_list", []() { return py::array_t<float>({ 1, 2 }); }); |
| 277 | sm.def("array_initializer_list", []() { return py::array_t<float>({ 1, 2, 3 }); }); |
| 278 | sm.def("array_initializer_list", []() { return py::array_t<float>({ 1, 2, 3, 4 }); }); |
uentity | 083a021 | 2017-04-13 21:41:55 +0500 | [diff] [blame] | 279 | |
| 280 | // reshape array to 2D without changing size |
| 281 | sm.def("array_reshape2", [](py::array_t<double> a) { |
Cris Luengo | 30d43c4 | 2017-04-14 14:33:44 -0600 | [diff] [blame] | 282 | const ssize_t dim_sz = (ssize_t)std::sqrt(a.size()); |
uentity | 083a021 | 2017-04-13 21:41:55 +0500 | [diff] [blame] | 283 | if (dim_sz * dim_sz != a.size()) |
| 284 | throw std::domain_error("array_reshape2: input array total size is not a squared integer"); |
| 285 | a.resize({dim_sz, dim_sz}); |
| 286 | }); |
| 287 | |
| 288 | // resize to 3D array with each dimension = N |
| 289 | sm.def("array_resize3", [](py::array_t<double> a, size_t N, bool refcheck) { |
| 290 | a.resize({N, N, N}, refcheck); |
| 291 | }); |
| 292 | |
| 293 | // return 2D array with Nrows = Ncols = N |
| 294 | sm.def("create_and_resize", [](size_t N) { |
| 295 | py::array_t<double> a; |
| 296 | a.resize({N, N}); |
| 297 | std::fill(a.mutable_data(), a.mutable_data() + a.size(), 42.); |
| 298 | return a; |
| 299 | }); |
Cris Luengo | d400f60 | 2017-04-05 16:13:04 -0600 | [diff] [blame] | 300 | }); |