test_numpy_array.cpp revision 12391
111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com tests/test_numpy_array.cpp -- test core array functionality 311986Sandreas.sandberg@arm.com 411986Sandreas.sandberg@arm.com Copyright (c) 2016 Ivan Smirnov <i.s.smirnov@gmail.com> 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 1211986Sandreas.sandberg@arm.com#include <pybind11/numpy.h> 1311986Sandreas.sandberg@arm.com#include <pybind11/stl.h> 1411986Sandreas.sandberg@arm.com 1511986Sandreas.sandberg@arm.com#include <cstdint> 1611986Sandreas.sandberg@arm.com 1711986Sandreas.sandberg@arm.comusing arr = py::array; 1811986Sandreas.sandberg@arm.comusing arr_t = py::array_t<uint16_t, 0>; 1912037Sandreas.sandberg@arm.comstatic_assert(std::is_same<arr_t::value_type, uint16_t>::value, ""); 2011986Sandreas.sandberg@arm.com 2111986Sandreas.sandberg@arm.comtemplate<typename... Ix> arr data(const arr& a, Ix... index) { 2211986Sandreas.sandberg@arm.com return arr(a.nbytes() - a.offset_at(index...), (const uint8_t *) a.data(index...)); 2311986Sandreas.sandberg@arm.com} 2411986Sandreas.sandberg@arm.com 2511986Sandreas.sandberg@arm.comtemplate<typename... Ix> arr data_t(const arr_t& a, Ix... index) { 2611986Sandreas.sandberg@arm.com return arr(a.size() - a.index_at(index...), a.data(index...)); 2711986Sandreas.sandberg@arm.com} 2811986Sandreas.sandberg@arm.com 2911986Sandreas.sandberg@arm.comtemplate<typename... Ix> arr& mutate_data(arr& a, Ix... index) { 3011986Sandreas.sandberg@arm.com auto ptr = (uint8_t *) a.mutable_data(index...); 3112391Sjason@lowepower.com for (ssize_t i = 0; i < a.nbytes() - a.offset_at(index...); i++) 3211986Sandreas.sandberg@arm.com ptr[i] = (uint8_t) (ptr[i] * 2); 3311986Sandreas.sandberg@arm.com return a; 3411986Sandreas.sandberg@arm.com} 3511986Sandreas.sandberg@arm.com 3611986Sandreas.sandberg@arm.comtemplate<typename... Ix> arr_t& mutate_data_t(arr_t& a, Ix... index) { 3711986Sandreas.sandberg@arm.com auto ptr = a.mutable_data(index...); 3812391Sjason@lowepower.com for (ssize_t i = 0; i < a.size() - a.index_at(index...); i++) 3911986Sandreas.sandberg@arm.com ptr[i]++; 4011986Sandreas.sandberg@arm.com return a; 4111986Sandreas.sandberg@arm.com} 4211986Sandreas.sandberg@arm.com 4312391Sjason@lowepower.comtemplate<typename... Ix> ssize_t index_at(const arr& a, Ix... idx) { return a.index_at(idx...); } 4412391Sjason@lowepower.comtemplate<typename... Ix> ssize_t index_at_t(const arr_t& a, Ix... idx) { return a.index_at(idx...); } 4512391Sjason@lowepower.comtemplate<typename... Ix> ssize_t offset_at(const arr& a, Ix... idx) { return a.offset_at(idx...); } 4612391Sjason@lowepower.comtemplate<typename... Ix> ssize_t offset_at_t(const arr_t& a, Ix... idx) { return a.offset_at(idx...); } 4712391Sjason@lowepower.comtemplate<typename... Ix> ssize_t at_t(const arr_t& a, Ix... idx) { return a.at(idx...); } 4811986Sandreas.sandberg@arm.comtemplate<typename... Ix> arr_t& mutate_at_t(arr_t& a, Ix... idx) { a.mutable_at(idx...)++; return a; } 4911986Sandreas.sandberg@arm.com 5011986Sandreas.sandberg@arm.com#define def_index_fn(name, type) \ 5111986Sandreas.sandberg@arm.com sm.def(#name, [](type a) { return name(a); }); \ 5211986Sandreas.sandberg@arm.com sm.def(#name, [](type a, int i) { return name(a, i); }); \ 5311986Sandreas.sandberg@arm.com sm.def(#name, [](type a, int i, int j) { return name(a, i, j); }); \ 5411986Sandreas.sandberg@arm.com sm.def(#name, [](type a, int i, int j, int k) { return name(a, i, j, k); }); 5511986Sandreas.sandberg@arm.com 5612037Sandreas.sandberg@arm.comtemplate <typename T, typename T2> py::handle auxiliaries(T &&r, T2 &&r2) { 5712037Sandreas.sandberg@arm.com if (r.ndim() != 2) throw std::domain_error("error: ndim != 2"); 5812037Sandreas.sandberg@arm.com py::list l; 5912037Sandreas.sandberg@arm.com l.append(*r.data(0, 0)); 6012037Sandreas.sandberg@arm.com l.append(*r2.mutable_data(0, 0)); 6112037Sandreas.sandberg@arm.com l.append(r.data(0, 1) == r2.mutable_data(0, 1)); 6212037Sandreas.sandberg@arm.com l.append(r.ndim()); 6312037Sandreas.sandberg@arm.com l.append(r.itemsize()); 6412037Sandreas.sandberg@arm.com l.append(r.shape(0)); 6512037Sandreas.sandberg@arm.com l.append(r.shape(1)); 6612037Sandreas.sandberg@arm.com l.append(r.size()); 6712037Sandreas.sandberg@arm.com l.append(r.nbytes()); 6812037Sandreas.sandberg@arm.com return l.release(); 6912037Sandreas.sandberg@arm.com} 7012037Sandreas.sandberg@arm.com 7112391Sjason@lowepower.comTEST_SUBMODULE(numpy_array, sm) { 7212391Sjason@lowepower.com try { py::module::import("numpy"); } 7312391Sjason@lowepower.com catch (...) { return; } 7411986Sandreas.sandberg@arm.com 7512391Sjason@lowepower.com // test_array_attributes 7611986Sandreas.sandberg@arm.com sm.def("ndim", [](const arr& a) { return a.ndim(); }); 7711986Sandreas.sandberg@arm.com sm.def("shape", [](const arr& a) { return arr(a.ndim(), a.shape()); }); 7812391Sjason@lowepower.com sm.def("shape", [](const arr& a, ssize_t dim) { return a.shape(dim); }); 7911986Sandreas.sandberg@arm.com sm.def("strides", [](const arr& a) { return arr(a.ndim(), a.strides()); }); 8012391Sjason@lowepower.com sm.def("strides", [](const arr& a, ssize_t dim) { return a.strides(dim); }); 8111986Sandreas.sandberg@arm.com sm.def("writeable", [](const arr& a) { return a.writeable(); }); 8211986Sandreas.sandberg@arm.com sm.def("size", [](const arr& a) { return a.size(); }); 8311986Sandreas.sandberg@arm.com sm.def("itemsize", [](const arr& a) { return a.itemsize(); }); 8411986Sandreas.sandberg@arm.com sm.def("nbytes", [](const arr& a) { return a.nbytes(); }); 8511986Sandreas.sandberg@arm.com sm.def("owndata", [](const arr& a) { return a.owndata(); }); 8611986Sandreas.sandberg@arm.com 8712391Sjason@lowepower.com // test_index_offset 8811986Sandreas.sandberg@arm.com def_index_fn(index_at, const arr&); 8911986Sandreas.sandberg@arm.com def_index_fn(index_at_t, const arr_t&); 9011986Sandreas.sandberg@arm.com def_index_fn(offset_at, const arr&); 9111986Sandreas.sandberg@arm.com def_index_fn(offset_at_t, const arr_t&); 9212391Sjason@lowepower.com // test_data 9312391Sjason@lowepower.com def_index_fn(data, const arr&); 9412391Sjason@lowepower.com def_index_fn(data_t, const arr_t&); 9512391Sjason@lowepower.com // test_mutate_data, test_mutate_readonly 9611986Sandreas.sandberg@arm.com def_index_fn(mutate_data, arr&); 9711986Sandreas.sandberg@arm.com def_index_fn(mutate_data_t, arr_t&); 9811986Sandreas.sandberg@arm.com def_index_fn(at_t, const arr_t&); 9911986Sandreas.sandberg@arm.com def_index_fn(mutate_at_t, arr_t&); 10011986Sandreas.sandberg@arm.com 10112391Sjason@lowepower.com // test_make_c_f_array 10212391Sjason@lowepower.com sm.def("make_f_array", [] { return py::array_t<float>({ 2, 2 }, { 4, 8 }); }); 10312391Sjason@lowepower.com sm.def("make_c_array", [] { return py::array_t<float>({ 2, 2 }, { 8, 4 }); }); 10411986Sandreas.sandberg@arm.com 10512391Sjason@lowepower.com // test_wrap 10611986Sandreas.sandberg@arm.com sm.def("wrap", [](py::array a) { 10711986Sandreas.sandberg@arm.com return py::array( 10811986Sandreas.sandberg@arm.com a.dtype(), 10912391Sjason@lowepower.com {a.shape(), a.shape() + a.ndim()}, 11012391Sjason@lowepower.com {a.strides(), a.strides() + a.ndim()}, 11111986Sandreas.sandberg@arm.com a.data(), 11211986Sandreas.sandberg@arm.com a 11311986Sandreas.sandberg@arm.com ); 11411986Sandreas.sandberg@arm.com }); 11511986Sandreas.sandberg@arm.com 11612391Sjason@lowepower.com // test_numpy_view 11711986Sandreas.sandberg@arm.com struct ArrayClass { 11811986Sandreas.sandberg@arm.com int data[2] = { 1, 2 }; 11911986Sandreas.sandberg@arm.com ArrayClass() { py::print("ArrayClass()"); } 12011986Sandreas.sandberg@arm.com ~ArrayClass() { py::print("~ArrayClass()"); } 12111986Sandreas.sandberg@arm.com }; 12211986Sandreas.sandberg@arm.com py::class_<ArrayClass>(sm, "ArrayClass") 12311986Sandreas.sandberg@arm.com .def(py::init<>()) 12411986Sandreas.sandberg@arm.com .def("numpy_view", [](py::object &obj) { 12511986Sandreas.sandberg@arm.com py::print("ArrayClass::numpy_view()"); 12611986Sandreas.sandberg@arm.com ArrayClass &a = obj.cast<ArrayClass&>(); 12711986Sandreas.sandberg@arm.com return py::array_t<int>({2}, {4}, a.data, obj); 12811986Sandreas.sandberg@arm.com } 12911986Sandreas.sandberg@arm.com ); 13011986Sandreas.sandberg@arm.com 13112391Sjason@lowepower.com // test_cast_numpy_int64_to_uint64 13211986Sandreas.sandberg@arm.com sm.def("function_taking_uint64", [](uint64_t) { }); 13311986Sandreas.sandberg@arm.com 13412391Sjason@lowepower.com // test_isinstance 13511986Sandreas.sandberg@arm.com sm.def("isinstance_untyped", [](py::object yes, py::object no) { 13611986Sandreas.sandberg@arm.com return py::isinstance<py::array>(yes) && !py::isinstance<py::array>(no); 13711986Sandreas.sandberg@arm.com }); 13811986Sandreas.sandberg@arm.com sm.def("isinstance_typed", [](py::object o) { 13911986Sandreas.sandberg@arm.com return py::isinstance<py::array_t<double>>(o) && !py::isinstance<py::array_t<int>>(o); 14011986Sandreas.sandberg@arm.com }); 14111986Sandreas.sandberg@arm.com 14212391Sjason@lowepower.com // test_constructors 14311986Sandreas.sandberg@arm.com sm.def("default_constructors", []() { 14411986Sandreas.sandberg@arm.com return py::dict( 14511986Sandreas.sandberg@arm.com "array"_a=py::array(), 14611986Sandreas.sandberg@arm.com "array_t<int32>"_a=py::array_t<std::int32_t>(), 14711986Sandreas.sandberg@arm.com "array_t<double>"_a=py::array_t<double>() 14811986Sandreas.sandberg@arm.com ); 14911986Sandreas.sandberg@arm.com }); 15011986Sandreas.sandberg@arm.com sm.def("converting_constructors", [](py::object o) { 15111986Sandreas.sandberg@arm.com return py::dict( 15211986Sandreas.sandberg@arm.com "array"_a=py::array(o), 15311986Sandreas.sandberg@arm.com "array_t<int32>"_a=py::array_t<std::int32_t>(o), 15411986Sandreas.sandberg@arm.com "array_t<double>"_a=py::array_t<double>(o) 15511986Sandreas.sandberg@arm.com ); 15611986Sandreas.sandberg@arm.com }); 15712037Sandreas.sandberg@arm.com 15812391Sjason@lowepower.com // test_overload_resolution 15912037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<double>) { return "double"; }); 16012037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<float>) { return "float"; }); 16112037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<int>) { return "int"; }); 16212037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<unsigned short>) { return "unsigned short"; }); 16312037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<long long>) { return "long long"; }); 16412037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<std::complex<double>>) { return "double complex"; }); 16512037Sandreas.sandberg@arm.com sm.def("overloaded", [](py::array_t<std::complex<float>>) { return "float complex"; }); 16612037Sandreas.sandberg@arm.com 16712037Sandreas.sandberg@arm.com sm.def("overloaded2", [](py::array_t<std::complex<double>>) { return "double complex"; }); 16812037Sandreas.sandberg@arm.com sm.def("overloaded2", [](py::array_t<double>) { return "double"; }); 16912037Sandreas.sandberg@arm.com sm.def("overloaded2", [](py::array_t<std::complex<float>>) { return "float complex"; }); 17012037Sandreas.sandberg@arm.com sm.def("overloaded2", [](py::array_t<float>) { return "float"; }); 17112037Sandreas.sandberg@arm.com 17212037Sandreas.sandberg@arm.com // Only accept the exact types: 17312037Sandreas.sandberg@arm.com sm.def("overloaded3", [](py::array_t<int>) { return "int"; }, py::arg().noconvert()); 17412037Sandreas.sandberg@arm.com sm.def("overloaded3", [](py::array_t<double>) { return "double"; }, py::arg().noconvert()); 17512037Sandreas.sandberg@arm.com 17612037Sandreas.sandberg@arm.com // Make sure we don't do unsafe coercion (e.g. float to int) when not using forcecast, but 17712037Sandreas.sandberg@arm.com // rather that float gets converted via the safe (conversion to double) overload: 17812037Sandreas.sandberg@arm.com sm.def("overloaded4", [](py::array_t<long long, 0>) { return "long long"; }); 17912037Sandreas.sandberg@arm.com sm.def("overloaded4", [](py::array_t<double, 0>) { return "double"; }); 18012037Sandreas.sandberg@arm.com 18112037Sandreas.sandberg@arm.com // But we do allow conversion to int if forcecast is enabled (but only if no overload matches 18212037Sandreas.sandberg@arm.com // without conversion) 18312037Sandreas.sandberg@arm.com sm.def("overloaded5", [](py::array_t<unsigned int>) { return "unsigned int"; }); 18412037Sandreas.sandberg@arm.com sm.def("overloaded5", [](py::array_t<double>) { return "double"; }); 18512037Sandreas.sandberg@arm.com 18612391Sjason@lowepower.com // test_greedy_string_overload 18712037Sandreas.sandberg@arm.com // Issue 685: ndarray shouldn't go to std::string overload 18812037Sandreas.sandberg@arm.com sm.def("issue685", [](std::string) { return "string"; }); 18912037Sandreas.sandberg@arm.com sm.def("issue685", [](py::array) { return "array"; }); 19012037Sandreas.sandberg@arm.com sm.def("issue685", [](py::object) { return "other"; }); 19112037Sandreas.sandberg@arm.com 19212391Sjason@lowepower.com // test_array_unchecked_fixed_dims 19312037Sandreas.sandberg@arm.com sm.def("proxy_add2", [](py::array_t<double> a, double v) { 19412037Sandreas.sandberg@arm.com auto r = a.mutable_unchecked<2>(); 19512391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 19612391Sjason@lowepower.com for (ssize_t j = 0; j < r.shape(1); j++) 19712037Sandreas.sandberg@arm.com r(i, j) += v; 19812037Sandreas.sandberg@arm.com }, py::arg().noconvert(), py::arg()); 19912037Sandreas.sandberg@arm.com 20012037Sandreas.sandberg@arm.com sm.def("proxy_init3", [](double start) { 20112037Sandreas.sandberg@arm.com py::array_t<double, py::array::c_style> a({ 3, 3, 3 }); 20212037Sandreas.sandberg@arm.com auto r = a.mutable_unchecked<3>(); 20312391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 20412391Sjason@lowepower.com for (ssize_t j = 0; j < r.shape(1); j++) 20512391Sjason@lowepower.com for (ssize_t k = 0; k < r.shape(2); k++) 20612037Sandreas.sandberg@arm.com r(i, j, k) = start++; 20712037Sandreas.sandberg@arm.com return a; 20812037Sandreas.sandberg@arm.com }); 20912037Sandreas.sandberg@arm.com sm.def("proxy_init3F", [](double start) { 21012037Sandreas.sandberg@arm.com py::array_t<double, py::array::f_style> a({ 3, 3, 3 }); 21112037Sandreas.sandberg@arm.com auto r = a.mutable_unchecked<3>(); 21212391Sjason@lowepower.com for (ssize_t k = 0; k < r.shape(2); k++) 21312391Sjason@lowepower.com for (ssize_t j = 0; j < r.shape(1); j++) 21412391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 21512037Sandreas.sandberg@arm.com r(i, j, k) = start++; 21612037Sandreas.sandberg@arm.com return a; 21712037Sandreas.sandberg@arm.com }); 21812037Sandreas.sandberg@arm.com sm.def("proxy_squared_L2_norm", [](py::array_t<double> a) { 21912037Sandreas.sandberg@arm.com auto r = a.unchecked<1>(); 22012037Sandreas.sandberg@arm.com double sumsq = 0; 22112391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 22212037Sandreas.sandberg@arm.com sumsq += r[i] * r(i); // Either notation works for a 1D array 22312037Sandreas.sandberg@arm.com return sumsq; 22412037Sandreas.sandberg@arm.com }); 22512037Sandreas.sandberg@arm.com 22612037Sandreas.sandberg@arm.com sm.def("proxy_auxiliaries2", [](py::array_t<double> a) { 22712037Sandreas.sandberg@arm.com auto r = a.unchecked<2>(); 22812037Sandreas.sandberg@arm.com auto r2 = a.mutable_unchecked<2>(); 22912037Sandreas.sandberg@arm.com return auxiliaries(r, r2); 23012037Sandreas.sandberg@arm.com }); 23112037Sandreas.sandberg@arm.com 23212391Sjason@lowepower.com // test_array_unchecked_dyn_dims 23312037Sandreas.sandberg@arm.com // Same as the above, but without a compile-time dimensions specification: 23412037Sandreas.sandberg@arm.com sm.def("proxy_add2_dyn", [](py::array_t<double> a, double v) { 23512037Sandreas.sandberg@arm.com auto r = a.mutable_unchecked(); 23612037Sandreas.sandberg@arm.com if (r.ndim() != 2) throw std::domain_error("error: ndim != 2"); 23712391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 23812391Sjason@lowepower.com for (ssize_t j = 0; j < r.shape(1); j++) 23912037Sandreas.sandberg@arm.com r(i, j) += v; 24012037Sandreas.sandberg@arm.com }, py::arg().noconvert(), py::arg()); 24112037Sandreas.sandberg@arm.com sm.def("proxy_init3_dyn", [](double start) { 24212037Sandreas.sandberg@arm.com py::array_t<double, py::array::c_style> a({ 3, 3, 3 }); 24312037Sandreas.sandberg@arm.com auto r = a.mutable_unchecked(); 24412037Sandreas.sandberg@arm.com if (r.ndim() != 3) throw std::domain_error("error: ndim != 3"); 24512391Sjason@lowepower.com for (ssize_t i = 0; i < r.shape(0); i++) 24612391Sjason@lowepower.com for (ssize_t j = 0; j < r.shape(1); j++) 24712391Sjason@lowepower.com for (ssize_t k = 0; k < r.shape(2); k++) 24812037Sandreas.sandberg@arm.com r(i, j, k) = start++; 24912037Sandreas.sandberg@arm.com return a; 25012037Sandreas.sandberg@arm.com }); 25112037Sandreas.sandberg@arm.com sm.def("proxy_auxiliaries2_dyn", [](py::array_t<double> a) { 25212037Sandreas.sandberg@arm.com return auxiliaries(a.unchecked(), a.mutable_unchecked()); 25312037Sandreas.sandberg@arm.com }); 25412037Sandreas.sandberg@arm.com 25512037Sandreas.sandberg@arm.com sm.def("array_auxiliaries2", [](py::array_t<double> a) { 25612037Sandreas.sandberg@arm.com return auxiliaries(a, a); 25712037Sandreas.sandberg@arm.com }); 25812391Sjason@lowepower.com 25912391Sjason@lowepower.com // test_array_failures 26012391Sjason@lowepower.com // Issue #785: Uninformative "Unknown internal error" exception when constructing array from empty object: 26112391Sjason@lowepower.com sm.def("array_fail_test", []() { return py::array(py::object()); }); 26212391Sjason@lowepower.com sm.def("array_t_fail_test", []() { return py::array_t<double>(py::object()); }); 26312391Sjason@lowepower.com // Make sure the error from numpy is being passed through: 26412391Sjason@lowepower.com sm.def("array_fail_test_negative_size", []() { int c = 0; return py::array(-1, &c); }); 26512391Sjason@lowepower.com 26612391Sjason@lowepower.com // test_initializer_list 26712391Sjason@lowepower.com // Issue (unnumbered; reported in #788): regression: initializer lists can be ambiguous 26812391Sjason@lowepower.com sm.def("array_initializer_list1", []() { return py::array_t<float>(1); }); // { 1 } also works, but clang warns about it 26912391Sjason@lowepower.com sm.def("array_initializer_list2", []() { return py::array_t<float>({ 1, 2 }); }); 27012391Sjason@lowepower.com sm.def("array_initializer_list3", []() { return py::array_t<float>({ 1, 2, 3 }); }); 27112391Sjason@lowepower.com sm.def("array_initializer_list4", []() { return py::array_t<float>({ 1, 2, 3, 4 }); }); 27212391Sjason@lowepower.com 27312391Sjason@lowepower.com // test_array_resize 27412391Sjason@lowepower.com // reshape array to 2D without changing size 27512391Sjason@lowepower.com sm.def("array_reshape2", [](py::array_t<double> a) { 27612391Sjason@lowepower.com const ssize_t dim_sz = (ssize_t)std::sqrt(a.size()); 27712391Sjason@lowepower.com if (dim_sz * dim_sz != a.size()) 27812391Sjason@lowepower.com throw std::domain_error("array_reshape2: input array total size is not a squared integer"); 27912391Sjason@lowepower.com a.resize({dim_sz, dim_sz}); 28012391Sjason@lowepower.com }); 28112391Sjason@lowepower.com 28212391Sjason@lowepower.com // resize to 3D array with each dimension = N 28312391Sjason@lowepower.com sm.def("array_resize3", [](py::array_t<double> a, size_t N, bool refcheck) { 28412391Sjason@lowepower.com a.resize({N, N, N}, refcheck); 28512391Sjason@lowepower.com }); 28612391Sjason@lowepower.com 28712391Sjason@lowepower.com // test_array_create_and_resize 28812391Sjason@lowepower.com // return 2D array with Nrows = Ncols = N 28912391Sjason@lowepower.com sm.def("create_and_resize", [](size_t N) { 29012391Sjason@lowepower.com py::array_t<double> a; 29112391Sjason@lowepower.com a.resize({N, N}); 29212391Sjason@lowepower.com std::fill(a.mutable_data(), a.mutable_data() + a.size(), 42.); 29312391Sjason@lowepower.com return a; 29412391Sjason@lowepower.com }); 29512391Sjason@lowepower.com} 296