pybind11/tests/test_numpy_array.cpp

19     py::dtype numpy{};
20     py::dtype pybind11{};
25     py::module np = py::module::import("numpy");
28     check.pybind11 = py::dtype::of<T>();
51     py::dtype dtype{};
57     check.name = py::type_id<T>();
59     check.dtype = py::dtype::of<T>();
78 using arr = py::array;
79 using arr_t = py::array_t<uint16_t, 0>;
117 template <typename T, typename T2> py::handle auxiliaries(T &&r, T2 &&r2) {
119     py::list l;
136     try { py::module::import("numpy"); }
140     py::class_<DtypeCheck>(sm, "DtypeCheck")
144             return py::str("<DtypeCheck numpy={} pybind11={}>").format(
149     py::class_<DtypeSizeCheck>(sm, "DtypeSizeCheck")
154             return py::str("<DtypeSizeCheck name='{}' size_cpp={} size_numpy={} dtype={}>").format(
186     sm.def("make_f_array", [] { return py::array_t<float>({ 2, 2 }, { 4, 8 }); });
187     sm.def("make_c_array", [] { return py::array_t<float>({ 2, 2 }, { 8, 4 }); });
190     sm.def("make_empty_shaped_array", [] { return py::array(py::dtype("f"), {}, {}); });
192     sm.def("scalar_int", []() { return py::array(py::dtype("i"), {}, {}, &data_i); });
195     sm.def("wrap", [](py::array a) {
196         return py::array(
208         ArrayClass() { py::print("ArrayClass()"); }
209         ~ArrayClass() { py::print("~ArrayClass()"); }
211     py::class_<ArrayClass>(sm, "ArrayClass")
212         .def(py::init<>())
213         .def("numpy_view", [](py::object &obj) {
214             py::print("ArrayClass::numpy_view()");
216             return py::array_t<int>({2}, {4}, a.data, obj);
224     sm.def("isinstance_untyped", [](py::object yes, py::object no) {
225         return py::isinstance<py::array>(yes) && !py::isinstance<py::array>(no);
227     sm.def("isinstance_typed", [](py::object o) {
228         return py::isinstance<py::array_t<double>>(o) && !py::isinstance<py::array_t<int>>(o);
233         return py::dict(
234             "array"_a=py::array(),
235             "array_t<int32>"_a=py::array_t<std::int32_t>(),
236             "array_t<double>"_a=py::array_t<double>()
239     sm.def("converting_constructors", [](py::object o) {
240         return py::dict(
241             "array"_a=py::array(o),
242             "array_t<int32>"_a=py::array_t<std::int32_t>(o),
243             "array_t<double>"_a=py::array_t<double>(o)
248     sm.def("overloaded", [](py::array_t<double>) { return "double"; });
249     sm.def("overloaded", [](py::array_t<float>) { return "float"; });
250     sm.def("overloaded", [](py::array_t<int>) { return "int"; });
251     sm.def("overloaded", [](py::array_t<unsigned short>) { return "unsigned short"; });
252     sm.def("overloaded", [](py::array_t<long long>) { return "long long"; });
253     sm.def("overloaded", [](py::array_t<std::complex<double>>) { return "double complex"; });
254     sm.def("overloaded", [](py::array_t<std::complex<float>>) { return "float complex"; });
256     sm.def("overloaded2", [](py::array_t<std::complex<double>>) { return "double complex"; });
257     sm.def("overloaded2", [](py::array_t<double>) { return "double"; });
258     sm.def("overloaded2", [](py::array_t<std::complex<float>>) { return "float complex"; });
259     sm.def("overloaded2", [](py::array_t<float>) { return "float"; });
262     sm.def("overloaded3", [](py::array_t<int>) { return "int"; }, py::arg().noconvert());
263     sm.def("overloaded3", [](py::array_t<double>) { return "double"; }, py::arg().noconvert());
267     sm.def("overloaded4", [](py::array_t<long long, 0>) { return "long long"; });
268     sm.def("overloaded4", [](py::array_t<double, 0>) { return "double"; });
272     sm.def("overloaded5", [](py::array_t<unsigned int>) { return "unsigned int"; });
273     sm.def("overloaded5", [](py::array_t<double>) { return "double"; });
278     sm.def("issue685", [](py::array) { return "array"; });
279     sm.def("issue685", [](py::object) { return "other"; });
282     sm.def("proxy_add2", [](py::array_t<double> a, double v) {
287     }, py::arg().noconvert(), py::arg());
290         py::array_t<double, py::array::c_style> a({ 3, 3, 3 });
299         py::array_t<double, py::array::f_style> a({ 3, 3, 3 });
307     sm.def("proxy_squared_L2_norm", [](py::array_t<double> a) {
315     sm.def("proxy_auxiliaries2", [](py::array_t<double> a) {
323     sm.def("proxy_add2_dyn", [](py::array_t<double> a, double v) {
329     }, py::arg().noconvert(), py::arg());
331         py::array_t<double, py::array::c_style> a({ 3, 3, 3 });
340     sm.def("proxy_auxiliaries2_dyn", [](py::array_t<double> a) {
344     sm.def("array_auxiliaries2", [](py::array_t<double> a) {
350     sm.def("array_fail_test", []() { return py::array(py::object()); });
351     sm.def("array_t_fail_test", []() { return py::array_t<double>(py::object()); });
353     sm.def("array_fail_test_negative_size", []() { int c = 0; return py::array(-1, &c); });
357     sm.def("array_initializer_list1", []() { return py::array_t<float>(1); }); // { 1 } also works, but clang warns about it
358     sm.def("array_initializer_list2", []() { return py::array_t<float>({ 1, 2 }); });
359     sm.def("array_initializer_list3", []() { return py::array_t<float>({ 1, 2, 3 }); });
360     sm.def("array_initializer_list4", []() { return py::array_t<float>({ 1, 2, 3, 4 }); });
364     sm.def("array_reshape2", [](py::array_t<double> a) {
372     sm.def("array_resize3", [](py::array_t<double> a, size_t N, bool refcheck) {
379         py::array_t<double> a;
386         sm.def("index_using_ellipsis", [](py::array a) {
387             return a[py::make_tuple(0, py::ellipsis(), 0)];