|
|
#ifndef NUMPY_WRAPPERS_H
|
|
|
#define NUMPY_WRAPPERS_H
|
|
|
#include <Data/ScalarTimeSerie.h>
|
|
|
#include <Data/VectorTimeSerie.h>
|
|
|
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
|
|
|
#if defined(slots) && (defined(__GNUC__) || defined(_MSC_VER) || defined(__clang__))
|
|
|
#pragma push_macro("slots")
|
|
|
#undef slots
|
|
|
extern "C"
|
|
|
{
|
|
|
/*
|
|
|
* Python 2 uses the "register" keyword, which is deprecated in C++ 11
|
|
|
* and forbidden in C++17.
|
|
|
*/
|
|
|
#if defined(__clang__)
|
|
|
#pragma clang diagnostic push
|
|
|
#pragma clang diagnostic ignored "-Wdeprecated-register"
|
|
|
#endif
|
|
|
|
|
|
#include <Python.h>
|
|
|
#include <numpy/arrayobject.h>
|
|
|
|
|
|
#if defined(__clang__)
|
|
|
#pragma clang diagnostic pop
|
|
|
#endif
|
|
|
}
|
|
|
#else
|
|
|
#include <Python.h>
|
|
|
#include <numpy/arrayobject.h>
|
|
|
#endif
|
|
|
#include <assert.h>
|
|
|
|
|
|
#include <map>
|
|
|
#include <warnings.h>
|
|
|
|
|
|
inline int init_numpy()
|
|
|
{
|
|
|
DISABLE_WARNING_PUSH
|
|
|
DISABLE_WARNING_CONVERSION_NULL
|
|
|
import_array(); // PyError if not successful
|
|
|
DISABLE_WARNING_POP
|
|
|
return 0;
|
|
|
}
|
|
|
const static int numpy_initialized = init_numpy();
|
|
|
template <typename dest_type = PyObject>
|
|
|
struct PyObjectWrapper
|
|
|
{
|
|
|
private:
|
|
|
PyObject* _py_obj = nullptr;
|
|
|
void inc_refcount() { Py_XINCREF(_py_obj); }
|
|
|
void dec_refcount()
|
|
|
{
|
|
|
Py_XDECREF(_py_obj);
|
|
|
_py_obj = nullptr;
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
PyObjectWrapper() : _py_obj { nullptr } {}
|
|
|
PyObjectWrapper(const PyObjectWrapper& other) : _py_obj { other._py_obj } { inc_refcount(); }
|
|
|
PyObjectWrapper(PyObjectWrapper&& other) : _py_obj { other._py_obj } { inc_refcount(); }
|
|
|
explicit PyObjectWrapper(PyObject* obj) : _py_obj { obj } { inc_refcount(); }
|
|
|
~PyObjectWrapper() { dec_refcount(); }
|
|
|
PyObjectWrapper& operator=(PyObjectWrapper&& other)
|
|
|
{
|
|
|
dec_refcount();
|
|
|
this->_py_obj = other._py_obj;
|
|
|
inc_refcount();
|
|
|
return *this;
|
|
|
}
|
|
|
PyObjectWrapper& operator=(const PyObjectWrapper& other)
|
|
|
{
|
|
|
dec_refcount();
|
|
|
this->_py_obj = other._py_obj;
|
|
|
inc_refcount();
|
|
|
return *this;
|
|
|
}
|
|
|
|
|
|
PyObject* py_object() { return _py_obj; }
|
|
|
inline dest_type* get() { return reinterpret_cast<dest_type*>(_py_obj); }
|
|
|
inline bool is_null() { return _py_obj == nullptr; }
|
|
|
};
|
|
|
|
|
|
struct NpArray_view
|
|
|
{
|
|
|
private:
|
|
|
PyObjectWrapper<PyArrayObject> _py_obj;
|
|
|
NpArray_view(const NpArray_view&& other) = delete;
|
|
|
|
|
|
public:
|
|
|
static bool isNpArray(PyObject* obj)
|
|
|
{
|
|
|
auto arr = reinterpret_cast<PyArrayObject*>(obj);
|
|
|
auto is_c_aray = obj && PyArray_Check(arr) && PyArray_ISCARRAY(arr);
|
|
|
return is_c_aray;
|
|
|
}
|
|
|
NpArray_view() : _py_obj { nullptr } {}
|
|
|
NpArray_view(const NpArray_view& other) : _py_obj { other._py_obj } {}
|
|
|
NpArray_view(NpArray_view&& other) : _py_obj { other._py_obj } {}
|
|
|
explicit NpArray_view(PyObject* obj) : _py_obj { obj }
|
|
|
{
|
|
|
assert(isNpArray(obj));
|
|
|
assert(PyArray_ISFLOAT(_py_obj.get()));
|
|
|
}
|
|
|
|
|
|
NpArray_view& operator=(const NpArray_view& other)
|
|
|
{
|
|
|
this->_py_obj = other._py_obj;
|
|
|
return *this;
|
|
|
}
|
|
|
|
|
|
NpArray_view& operator=(NpArray_view&& other)
|
|
|
{
|
|
|
this->_py_obj = other._py_obj;
|
|
|
return *this;
|
|
|
}
|
|
|
|
|
|
std::vector<std::size_t> shape()
|
|
|
{
|
|
|
std::vector<std::size_t> shape;
|
|
|
if (!_py_obj.is_null())
|
|
|
{
|
|
|
if (int ndim = PyArray_NDIM(_py_obj.get()); ndim > 0)
|
|
|
{
|
|
|
if (ndim < 10)
|
|
|
{
|
|
|
shape.resize(ndim);
|
|
|
std::copy_n(PyArray_SHAPE(_py_obj.get()), ndim, std::begin(shape));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return shape;
|
|
|
}
|
|
|
|
|
|
std::size_t ndim()
|
|
|
{
|
|
|
if (!_py_obj.is_null())
|
|
|
{
|
|
|
return static_cast<std::size_t>(PyArray_NDIM(_py_obj.get()));
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
std::size_t size(std::size_t index = 0)
|
|
|
{
|
|
|
if (!_py_obj.is_null())
|
|
|
{
|
|
|
if (index < static_cast<std::size_t>(PyArray_NDIM(_py_obj.get())))
|
|
|
{
|
|
|
return PyArray_SHAPE(_py_obj.get())[index];
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
std::size_t flat_size()
|
|
|
{
|
|
|
auto s = this->shape();
|
|
|
return std::accumulate(
|
|
|
std::cbegin(s), std::cend(s), 1, [](const auto& a, const auto& b) { return a * b; });
|
|
|
}
|
|
|
|
|
|
double data(std::size_t pos)
|
|
|
{
|
|
|
if (!_py_obj.is_null())
|
|
|
{
|
|
|
return reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()))[pos];
|
|
|
}
|
|
|
return nan("NAN");
|
|
|
}
|
|
|
|
|
|
std::vector<double> to_std_vect()
|
|
|
{
|
|
|
assert(!this->_py_obj.is_null());
|
|
|
auto sz = flat_size();
|
|
|
std::vector<double> v(sz);
|
|
|
auto d_ptr = reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()));
|
|
|
std::copy(d_ptr, d_ptr + sz, std::begin(v));
|
|
|
return v;
|
|
|
}
|
|
|
|
|
|
std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
|
|
|
{
|
|
|
auto sz = size(0);
|
|
|
std::vector<VectorTimeSerie::raw_value_type> v(sz);
|
|
|
if (sz)
|
|
|
{
|
|
|
assert(ndim() == 2);
|
|
|
assert(size(1) == 3);
|
|
|
auto d_ptr
|
|
|
= reinterpret_cast<VectorTimeSerie::raw_value_type*>(PyArray_DATA(_py_obj.get()));
|
|
|
std::copy(d_ptr, d_ptr + sz, std::begin(v));
|
|
|
}
|
|
|
return v;
|
|
|
}
|
|
|
|
|
|
PyObject* py_object() { return _py_obj.py_object(); }
|
|
|
};
|
|
|
|
|
|
struct NpArray
|
|
|
{
|
|
|
std::vector<std::size_t> shape;
|
|
|
std::vector<double> data;
|
|
|
static bool isNpArray(PyObject* obj) { return NpArray_view::isNpArray(obj); }
|
|
|
NpArray() = default;
|
|
|
explicit NpArray(PyObject* obj)
|
|
|
{
|
|
|
if (obj)
|
|
|
{
|
|
|
NpArray_view view { obj };
|
|
|
shape = view.shape();
|
|
|
data = view.to_std_vect();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
inline std::size_t ndim() { return shape.size(); }
|
|
|
|
|
|
std::size_t size(std::size_t index = 0)
|
|
|
{
|
|
|
if (index < shape.size())
|
|
|
return shape[index];
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
std::size_t flat_size()
|
|
|
{
|
|
|
return std::accumulate(std::cbegin(shape), std::cend(shape), 1,
|
|
|
[](const auto& a, const auto& b) { return a * b; });
|
|
|
}
|
|
|
|
|
|
// TODO temporary hack should find a way to avoid this copy
|
|
|
std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
|
|
|
{
|
|
|
auto sz = size(0);
|
|
|
std::vector<VectorTimeSerie::raw_value_type> v(sz);
|
|
|
if (sz)
|
|
|
{
|
|
|
assert(ndim() == 2);
|
|
|
assert(size(1) == 3);
|
|
|
auto d_ptr = reinterpret_cast<VectorTimeSerie::raw_value_type*>(data.data());
|
|
|
std::copy(d_ptr, d_ptr + sz, std::begin(v));
|
|
|
}
|
|
|
return v;
|
|
|
}
|
|
|
|
|
|
// TODO maybe ;)
|
|
|
PyObject* py_object() { return nullptr; }
|
|
|
};
|
|
|
|
|
|
inline int test_np_array(NpArray& arr)
|
|
|
{
|
|
|
auto shape = arr.shape;
|
|
|
std::cout << "len(shape)=" << shape.size() << std::endl;
|
|
|
std::for_each(std::cbegin(shape), std::cend(shape), [](auto sz) {
|
|
|
static int i = 0;
|
|
|
std::cout << "shape[" << i++ << "]=" << sz << std::endl;
|
|
|
});
|
|
|
auto flatsize = std::accumulate(std::cbegin(shape), std::cend(shape), 0);
|
|
|
for (auto i = 0; i < flatsize; i++)
|
|
|
{
|
|
|
std::cout << "data[" << i << "]=" << arr.data[i] << std::endl;
|
|
|
}
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
#endif //#ifndef NUMPY_WRAPPERS_H
|
|
|
|
