Skip to content

Commit c9932ee

Browse files
WentzellWentzell
committed
Convert std::vector and std::array of non-basic types to NPY arrays
1 parent 3e4667a commit c9932ee

File tree

2 files changed

+146
-75
lines changed

2 files changed

+146
-75
lines changed

‎c++/cpp2py/converters/std_array.hpp

+104-31
Original file line numberDiff line numberDiff line change
@@ -1,54 +1,127 @@
11
#pragma once
22
#include <array>
3+
#include <numpy/arrayobject.h>
4+
5+
#include "../numpy_proxy.hpp"
6+
#include "../py_converter.hpp"
7+
#include "./vector.hpp"
38

49
namespace cpp2py {
510

6-
template <typename T, size_t R> struct py_converter<std::array<T, R>> {
7-
// --------------------------------------
11+
template <typename T, size_t R> numpy_proxy make_numpy_proxy_from_heap_array(std::array<T, R> *arr_heap) {
812

9-
static PyObject *c2py(std::array<T, R> const &v) {
10-
PyObject *list = PyList_New(0);
11-
for (auto const &x : v) {
12-
pyref y = py_converter<T>::c2py(x);
13-
if (y.is_null() or (PyList_Append(list, y) == -1)) {
14-
Py_DECREF(list);
15-
return NULL;
16-
} // error
17-
}
18-
return list;
13+
auto delete_pycapsule = [](PyObject *capsule) {
14+
auto *ptr = static_cast<std::array<T, R> *>(PyCapsule_GetPointer(capsule, "guard"));
15+
delete ptr;
16+
};
17+
PyObject *capsule = PyCapsule_New(arr_heap, "guard", delete_pycapsule);
18+
19+
return numpy_proxy{1, // rank
20+
npy_type<std::decay_t<T>>,
21+
(void *)arr_heap->data(),
22+
std::is_const_v<T>,
23+
std::vector<long>{long(R)}, // extents
24+
std::vector<long>{sizeof(T)}, // strides
25+
capsule};
26+
};
27+
28+
template <typename T, size_t R> numpy_proxy make_numpy_proxy_from_array(std::array<T, R> const &arr) {
29+
30+
if constexpr (has_npy_type<T>) {
31+
auto *arr_heap = new std::array<T, R>{arr};
32+
return make_numpy_proxy_from_heap_array(arr_heap);
33+
} else {
34+
auto *arr_heap = new std::array<pyref, R>{};
35+
std::transform(begin(arr), end(arr), begin(*arr_heap), [](T const &x) { return py_converter<std::decay_t<T>>::c2py(x); });
36+
return make_numpy_proxy_from_heap_array(arr_heap);
1937
}
38+
}
39+
40+
// Make a new array from numpy view
41+
template <typename T, size_t R> std::array<T, R> make_array_from_numpy_proxy(numpy_proxy const &p) {
42+
EXPECTS(p.extents.size() == 1);
43+
EXPECTS(p.extents[0] == R);
44+
45+
std::array<T, R> arr;
46+
47+
if (p.element_type == npy_type<pyref>) {
48+
auto *data = static_cast<pyref *>(p.data);
49+
std::transform(data, data + R, begin(arr), [](PyObject *o) { return py_converter<std::decay_t<T>>::py2c(o); });
50+
} else {
51+
EXPECTS(p.strides == std::vector<long>{sizeof(T)});
52+
T *data = static_cast<T *>(p.data);
53+
std::copy(data, data + R, begin(arr));
54+
}
55+
56+
return arr;
57+
}
58+
59+
// --------------------------------------
60+
61+
template <typename T, size_t R> struct py_converter<std::array<T, R>> {
62+
63+
static PyObject *c2py(std::array<T, R> const &a) { return make_numpy_proxy_from_array(a).to_python(); }
2064

2165
// --------------------------------------
2266

2367
static bool is_convertible(PyObject *ob, bool raise_exception) {
24-
if (!PySequence_Check(ob)) goto _false;
25-
{
26-
pyref seq = PySequence_Fast(ob, "expected a sequence");
27-
int len = PySequence_Size(ob);
28-
if (len != R) {
29-
if (raise_exception) {
30-
auto s = std::string{"Convertion to std::array<T, R> failed : the length of the sequence ( = "} + std::to_string(len)
31-
+ " does not match R = " + std::to_string(R);
32-
PyErr_SetString(PyExc_TypeError, s.c_str());
33-
}
68+
_import_array();
69+
70+
// Special case: 1-d ndarray of builtin type
71+
if (PyArray_Check(ob)) {
72+
PyArrayObject *arr = (PyArrayObject *)(ob);
73+
#ifdef PYTHON_NUMPY_VERSION_LT_17
74+
int rank = arr->nd;
75+
#else
76+
int rank = PyArray_NDIM(arr);
77+
#endif
78+
if (PyArray_TYPE(arr) == npy_type<T> and rank == 1) return true;
79+
}
80+
81+
if (!PySequence_Check(ob)) {
82+
if (raise_exception) { PyErr_SetString(PyExc_TypeError, "Cannot convert a non-sequence to std::array"); }
83+
return false;
84+
}
85+
86+
pyref seq = PySequence_Fast(ob, "expected a sequence");
87+
int len = PySequence_Size(ob);
88+
if (len != R) {
89+
if (raise_exception) {
90+
auto s = std::string{"Convertion to std::array<T, R> failed : the length of the sequence ( = "} + std::to_string(len)
91+
+ " does not match R = " + std::to_string(R);
92+
PyErr_SetString(PyExc_TypeError, s.c_str());
93+
}
94+
return false;
95+
}
96+
for (int i = 0; i < len; i++) {
97+
if (!py_converter<std::decay_t<T>>::is_convertible(PySequence_Fast_GET_ITEM((PyObject *)seq, i), raise_exception)) {
98+
if (PyErr_Occurred()) PyErr_Print();
3499
return false;
35100
}
36-
for (int i = 0; i < len; i++)
37-
if (!py_converter<T>::is_convertible(PySequence_Fast_GET_ITEM((PyObject *)seq, i), raise_exception)) goto _false; // borrowed ref
38-
39-
return true;
40101
}
41-
_false:
42-
if (raise_exception) { PyErr_SetString(PyExc_TypeError, "Cannot convert to std::array"); }
43-
return false;
102+
return true;
44103
}
45104

46105
// --------------------------------------
47106

48107
static std::array<T, R> py2c(PyObject *ob) {
49-
pyref seq = PySequence_Fast(ob, "expected a sequence");
108+
_import_array();
109+
110+
// Special case: 1-d ndarray of builtin type
111+
if (PyArray_Check(ob)) {
112+
PyArrayObject *arr = (PyArrayObject *)(ob);
113+
#ifdef PYTHON_NUMPY_VERSION_LT_17
114+
int rank = arr->nd;
115+
#else
116+
int rank = PyArray_NDIM(arr);
117+
#endif
118+
if (rank == 1) return make_array_from_numpy_proxy<T, R>(make_numpy_proxy(ob));
119+
}
120+
121+
ASSERT(PySequence_Check(ob));
50122
std::array<T, R> res;
51-
for (int i = 0; i < R; i++) res[i] = py_converter<T>::py2c(PySequence_Fast_GET_ITEM((PyObject *)seq, i)); // borrowed ref
123+
pyref seq = PySequence_Fast(ob, "expected a sequence");
124+
for (int i = 0; i < R; i++) res[i] = py_converter<std::decay_t<T>>::py2c(PySequence_Fast_GET_ITEM((PyObject *)seq, i)); // borrowed ref
52125
return res;
53126
}
54127
};

‎c++/cpp2py/converters/vector.hpp

+42-44
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
#include "../traits.hpp"
77
#include "../macros.hpp"
88
#include "../numpy_proxy.hpp"
9+
#include "../py_converter.hpp"
910

1011
namespace cpp2py {
1112

@@ -14,35 +15,54 @@ namespace cpp2py {
1415
static_assert(is_instantiation_of_v<std::vector, std::decay_t<V>>, "Logic error");
1516
using value_type = typename std::remove_reference_t<V>::value_type;
1617

17-
auto *vec_heap = new std::vector<value_type>{std::forward<V>(v)};
18-
auto delete_pycapsule = [](PyObject *capsule) {
19-
auto *ptr = static_cast<std::vector<value_type> *>(PyCapsule_GetPointer(capsule, "guard"));
20-
delete ptr;
21-
};
22-
PyObject *capsule = PyCapsule_New(vec_heap, "guard", delete_pycapsule);
23-
24-
return {1, // rank
25-
npy_type<value_type>,
26-
(void *)vec_heap->data(),
27-
std::is_const_v<value_type>,
28-
std::vector<long>{long(vec_heap->size())}, // extents
29-
std::vector<long>{sizeof(value_type)}, // strides
30-
capsule};
18+
if constexpr (has_npy_type<value_type>) {
19+
auto *vec_heap = new std::vector<value_type>{std::forward<V>(v)};
20+
auto delete_pycapsule = [](PyObject *capsule) {
21+
auto *ptr = static_cast<std::vector<value_type> *>(PyCapsule_GetPointer(capsule, "guard"));
22+
delete ptr;
23+
};
24+
PyObject *capsule = PyCapsule_New(vec_heap, "guard", delete_pycapsule);
25+
26+
return {1, // rank
27+
npy_type<value_type>,
28+
(void *)vec_heap->data(),
29+
std::is_const_v<value_type>,
30+
std::vector<long>{long(vec_heap->size())}, // extents
31+
std::vector<long>{sizeof(value_type)}, // strides
32+
capsule};
33+
} else {
34+
std::vector<pyref> vobj(v.size());
35+
std::transform(begin(v), end(v), begin(vobj), [](auto &&x) {
36+
if constexpr (std::is_reference_v<V>) {
37+
return convert_to_python(x);
38+
} else { // vector passed as rvalue
39+
return convert_to_python(std::move(x));
40+
}
41+
});
42+
return make_numpy_proxy_from_vector(std::move(vobj));
43+
}
3144
}
3245

3346
// Make a new vector from numpy view
3447
template <typename T> std::vector<T> make_vector_from_numpy_proxy(numpy_proxy const &p) {
3548
EXPECTS(p.extents.size() == 1);
36-
EXPECTS(p.strides[0] % sizeof(T) == 0);
3749

3850
long size = p.extents[0];
39-
long step = p.strides[0] / sizeof(T);
4051

4152
std::vector<T> v(size);
4253

43-
T *data = static_cast<T *>(p.data);
44-
for(long i = 0; i < size; ++i)
45-
v[i] = *(data + i * step);
54+
if (p.element_type == npy_type<pyref>) {
55+
long step = p.strides[0] / sizeof(pyref);
56+
auto **data = static_cast<PyObject **>(p.data);
57+
for(long i = 0; i < size; ++i)
58+
v[i] = py_converter<std::decay_t<T>>::py2c(data[i * step]);
59+
} else {
60+
EXPECTS(p.strides[0] % sizeof(T) == 0);
61+
long step = p.strides[0] / sizeof(T);
62+
T *data = static_cast<T *>(p.data);
63+
for(long i = 0; i < size; ++i)
64+
v[i] = data[i * step];
65+
}
4666

4767
return v;
4868
}
@@ -53,26 +73,7 @@ namespace cpp2py {
5373

5474
template <typename V> static PyObject *c2py(V &&v) {
5575
static_assert(is_instantiation_of_v<std::vector, std::decay_t<V>>, "Logic error");
56-
using value_type = typename std::remove_reference_t<V>::value_type;
57-
58-
if constexpr (has_npy_type<value_type>) {
59-
return make_numpy_proxy_from_vector(std::forward<V>(v)).to_python();
60-
} else { // Convert to Python List
61-
PyObject *list = PyList_New(0);
62-
for (auto &x : v) {
63-
pyref y;
64-
if constexpr(std::is_reference_v<V>){
65-
y = py_converter<value_type>::c2py(x);
66-
} else { // Vector passed as rvalue
67-
y = py_converter<value_type>::c2py(std::move(x));
68-
}
69-
if (y.is_null() or (PyList_Append(list, y) == -1)) {
70-
Py_DECREF(list);
71-
return NULL;
72-
} // error
73-
}
74-
return list;
75-
}
76+
return make_numpy_proxy_from_vector(std::forward<V>(v)).to_python();
7677
}
7778

7879
// --------------------------------------
@@ -99,11 +100,8 @@ namespace cpp2py {
99100
pyref seq = PySequence_Fast(ob, "expected a sequence");
100101
int len = PySequence_Size(ob);
101102
for (int i = 0; i < len; i++) {
102-
if (!py_converter<T>::is_convertible(PySequence_Fast_GET_ITEM((PyObject *)seq, i), false)) { // borrowed ref
103-
if (raise_exception) {
104-
auto err = std::string{"Cannot convert sequence to std::vector due to element at position "} + std::to_string(i);
105-
PyErr_SetString(PyExc_TypeError, err.c_str());
106-
}
103+
if (!py_converter<std::decay_t<T>>::is_convertible(PySequence_Fast_GET_ITEM((PyObject *)seq, i), raise_exception)) { // borrowed ref
104+
if (PyErr_Occurred()) PyErr_Print();
107105
return false;
108106
}
109107
}

0 commit comments

Comments
 (0)