[ceph.git] / ceph / src / boost / libs / python / src / numpy / ndarray.cpp

// Copyright Jim Bosch 2010-2012.
// Copyright Stefan Seefeld 2016.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_PYTHON_NUMPY_INTERNAL
#include <boost/python/numpy/internal.hpp>
#include <boost/scoped_array.hpp>

namespace boost { namespace python {
namespace converter 
{
NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArray_Type, numpy::ndarray)
} // namespace boost::python::converter

namespace numpy 
{
namespace detail 
{

ndarray::bitflag numpy_to_bitflag(int const f)
{
  ndarray::bitflag r = ndarray::NONE;
  if (f & NPY_ARRAY_C_CONTIGUOUS) r = (r | ndarray::C_CONTIGUOUS);
  if (f & NPY_ARRAY_F_CONTIGUOUS) r = (r | ndarray::F_CONTIGUOUS);
  if (f & NPY_ARRAY_ALIGNED) r = (r | ndarray::ALIGNED);
  if (f & NPY_ARRAY_WRITEABLE) r = (r | ndarray::WRITEABLE);
  return r;
}

int bitflag_to_numpy(ndarray::bitflag f)
{
  int r = 0;
  if (f & ndarray::C_CONTIGUOUS) r |= NPY_ARRAY_C_CONTIGUOUS;
  if (f & ndarray::F_CONTIGUOUS) r |= NPY_ARRAY_F_CONTIGUOUS;
  if (f & ndarray::ALIGNED) r |= NPY_ARRAY_ALIGNED;
  if (f & ndarray::WRITEABLE) r |= NPY_ARRAY_WRITEABLE;
  return r;
}

bool is_c_contiguous(std::vector<Py_intptr_t> const & shape,
		     std::vector<Py_intptr_t> const & strides,
		     int itemsize)
{
  std::vector<Py_intptr_t>::const_reverse_iterator j = strides.rbegin();
  int total = itemsize;
  for (std::vector<Py_intptr_t>::const_reverse_iterator i = shape.rbegin(); i != shape.rend(); ++i, ++j) 
  {
    if (total != *j) return false;
    total *= (*i);
  }
  return true;
}

bool is_f_contiguous(std::vector<Py_intptr_t> const & shape,
		     std::vector<Py_intptr_t> const & strides,
		     int itemsize)
{
  std::vector<Py_intptr_t>::const_iterator j = strides.begin();
  int total = itemsize;
  for (std::vector<Py_intptr_t>::const_iterator i = shape.begin(); i != shape.end(); ++i, ++j)
  {
    if (total != *j) return false;
    total *= (*i);
  }
  return true;
}

bool is_aligned(std::vector<Py_intptr_t> const & strides,
		int itemsize)
{
  for (std::vector<Py_intptr_t>::const_iterator i = strides.begin(); i != strides.end(); ++i) 
  {
    if (*i % itemsize) return false;
  }
  return true;
}

inline PyArray_Descr * incref_dtype(dtype const & dt) 
{
  Py_INCREF(dt.ptr());
  return reinterpret_cast<PyArray_Descr*>(dt.ptr());
}

ndarray from_data_impl(void * data, 
		       dtype const & dt, 
		       python::object const & shape,
		       python::object const & strides,
		       python::object const & owner,
		       bool writeable)
{
  std::vector<Py_intptr_t> shape_(len(shape));
  std::vector<Py_intptr_t> strides_(len(strides));
  if (shape_.size() != strides_.size()) 
  {
    PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match.");
    python::throw_error_already_set();
  }
  for (std::size_t i = 0; i < shape_.size(); ++i) 
  {
    shape_[i] = python::extract<Py_intptr_t>(shape[i]);
    strides_[i] = python::extract<Py_intptr_t>(strides[i]);
  }
  return from_data_impl(data, dt, shape_, strides_, owner, writeable);
}

ndarray from_data_impl(void * data, 
		       dtype const & dt, 
		       std::vector<Py_intptr_t> const & shape,
		       std::vector<Py_intptr_t> const & strides,
		       python::object const & owner,
		       bool writeable)
{
  if (shape.size() != strides.size()) 
  {
    PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match.");
    python::throw_error_already_set();
  }
  int itemsize = dt.get_itemsize();
  int flags = 0;
  if (writeable) flags |= NPY_ARRAY_WRITEABLE;
  if (is_c_contiguous(shape, strides, itemsize)) flags |= NPY_ARRAY_C_CONTIGUOUS;
  if (is_f_contiguous(shape, strides, itemsize)) flags |= NPY_ARRAY_F_CONTIGUOUS;
  if (is_aligned(strides, itemsize)) flags |= NPY_ARRAY_ALIGNED;
  ndarray r(python::detail::new_reference
    (PyArray_NewFromDescr(&PyArray_Type,
			  incref_dtype(dt),
			  shape.size(),
			  const_cast<Py_intptr_t*>(&shape.front()),
			  const_cast<Py_intptr_t*>(&strides.front()),
			  data,
			  flags,
			  NULL)));
    r.set_base(owner);
    return r;
}

} // namespace detail

namespace {
    int normalize_index(int n,int nlim) // wraps [-nlim:nlim) into [0:nlim), throw IndexError otherwise
    {
        if (n<0)
            n += nlim; // negative indices work backwards from end
        if (n < 0 || n >= nlim)
        {
            PyErr_SetObject(PyExc_IndexError, Py_None);
            throw_error_already_set();
        }
        return n;
    }
}

Py_intptr_t ndarray::shape(int n) const
{
    return get_shape()[normalize_index(n,get_nd())];
}

Py_intptr_t ndarray::strides(int n) const
{
    return get_strides()[normalize_index(n,get_nd())];
}

ndarray ndarray::view(dtype const & dt) const
{
  return ndarray(python::detail::new_reference
    (PyObject_CallMethod(this->ptr(), const_cast<char*>("view"), const_cast<char*>("O"), dt.ptr())));
}
    
ndarray ndarray::astype(dtype const & dt) const
{
  return ndarray(python::detail::new_reference
    (PyObject_CallMethod(this->ptr(), const_cast<char*>("astype"), const_cast<char*>("O"), dt.ptr())));
}

ndarray ndarray::copy() const 
{
  return ndarray(python::detail::new_reference
    (PyObject_CallMethod(this->ptr(), const_cast<char*>("copy"), const_cast<char*>(""))));
}

dtype ndarray::get_dtype() const 
{
  return dtype(python::detail::borrowed_reference(get_struct()->descr));
}

python::object ndarray::get_base() const 
{
  if (get_struct()->base == NULL) return object();
  return python::object(python::detail::borrowed_reference(get_struct()->base));
}

void ndarray::set_base(object const & base) 
{
  Py_XDECREF(get_struct()->base);
  if (base.ptr())
  {
    Py_INCREF(base.ptr());
    get_struct()->base = base.ptr();
  }
  else
  {
    get_struct()->base = NULL;
  }
}

ndarray::bitflag ndarray::get_flags() const
{
  return numpy::detail::numpy_to_bitflag(get_struct()->flags);
}

ndarray ndarray::transpose() const 
{
  return ndarray(python::detail::new_reference
    (PyArray_Transpose(reinterpret_cast<PyArrayObject*>(this->ptr()), NULL)));
}

ndarray ndarray::squeeze() const 
{
  return ndarray(python::detail::new_reference
    (PyArray_Squeeze(reinterpret_cast<PyArrayObject*>(this->ptr()))));
}

ndarray ndarray::reshape(python::tuple const & shape) const 
{
  return ndarray(python::detail::new_reference
    (PyArray_Reshape(reinterpret_cast<PyArrayObject*>(this->ptr()), shape.ptr())));
}

python::object ndarray::scalarize() const 
{
  Py_INCREF(ptr());
  return python::object(python::detail::new_reference(PyArray_Return(reinterpret_cast<PyArrayObject*>(ptr()))));
}

ndarray zeros(python::tuple const & shape, dtype const & dt) 
{
  int nd = len(shape);
  boost::scoped_array<Py_intptr_t> dims(new Py_intptr_t[nd]);
  for (int n=0; n<nd; ++n) dims[n] = python::extract<Py_intptr_t>(shape[n]);
  return ndarray(python::detail::new_reference
                 (PyArray_Zeros(nd, dims.get(), detail::incref_dtype(dt), 0)));
}

ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt) 
{
  return ndarray(python::detail::new_reference
    (PyArray_Zeros(nd, const_cast<Py_intptr_t*>(shape), detail::incref_dtype(dt), 0)));
}

ndarray empty(python::tuple const & shape, dtype const & dt) 
{
  int nd = len(shape);
  boost::scoped_array<Py_intptr_t> dims(new Py_intptr_t[nd]);
  for (int n=0; n<nd; ++n) dims[n] = python::extract<Py_intptr_t>(shape[n]);
  return ndarray(python::detail::new_reference
                 (PyArray_Empty(nd, dims.get(), detail::incref_dtype(dt), 0)));    
}

ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt)
{
  return ndarray(python::detail::new_reference
    (PyArray_Empty(nd, const_cast<Py_intptr_t*>(shape), detail::incref_dtype(dt), 0)));
}

ndarray array(python::object const & obj) 
{
  return ndarray(python::detail::new_reference
    (PyArray_FromAny(obj.ptr(), NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL)));
}

ndarray array(python::object const & obj, dtype const & dt) 
{
  return ndarray(python::detail::new_reference
    (PyArray_FromAny(obj.ptr(), detail::incref_dtype(dt), 0, 0, NPY_ARRAY_ENSUREARRAY, NULL)));
}

ndarray from_object(python::object const & obj, dtype const & dt, int nd_min, int nd_max, ndarray::bitflag flags)
{
  int requirements = detail::bitflag_to_numpy(flags);
  return ndarray(python::detail::new_reference
    (PyArray_FromAny(obj.ptr(),
		     detail::incref_dtype(dt),
		     nd_min, nd_max,
		     requirements,
		     NULL)));
}

ndarray from_object(python::object const & obj, int nd_min, int nd_max, ndarray::bitflag flags) 
{
  int requirements = detail::bitflag_to_numpy(flags);
  return ndarray(python::detail::new_reference
    (PyArray_FromAny(obj.ptr(),
		     NULL,
		     nd_min, nd_max,
		     requirements,
		     NULL)));
}

}}} // namespace boost::python::numpy
Commit	Line	Data
7c673cae FG	1	// Copyright Jim Bosch 2010-2012.
	2	// Copyright Stefan Seefeld 2016.
	3	// Distributed under the Boost Software License, Version 1.0.
	4	// (See accompanying file LICENSE_1_0.txt or copy at
	5	// http://www.boost.org/LICENSE_1_0.txt)
	6
	7	#define BOOST_PYTHON_NUMPY_INTERNAL
	8	#include <boost/python/numpy/internal.hpp>
	9	#include <boost/scoped_array.hpp>
	10
	11	namespace boost { namespace python {
	12	namespace converter
	13	{
	14	NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArray_Type, numpy::ndarray)
	15	} // namespace boost::python::converter
	16
	17	namespace numpy
	18	{
	19	namespace detail
	20	{
	21
	22	ndarray::bitflag numpy_to_bitflag(int const f)
	23	{
	24	ndarray::bitflag r = ndarray::NONE;
b32b8144 FG	25	if (f & NPY_ARRAY_C_CONTIGUOUS) r = (r \| ndarray::C_CONTIGUOUS);
	26	if (f & NPY_ARRAY_F_CONTIGUOUS) r = (r \| ndarray::F_CONTIGUOUS);
	27	if (f & NPY_ARRAY_ALIGNED) r = (r \| ndarray::ALIGNED);
	28	if (f & NPY_ARRAY_WRITEABLE) r = (r \| ndarray::WRITEABLE);
7c673cae FG	29	return r;
	30	}
	31
	32	int bitflag_to_numpy(ndarray::bitflag f)
	33	{
	34	int r = 0;
b32b8144 FG	35	if (f & ndarray::C_CONTIGUOUS) r \|= NPY_ARRAY_C_CONTIGUOUS;
	36	if (f & ndarray::F_CONTIGUOUS) r \|= NPY_ARRAY_F_CONTIGUOUS;
	37	if (f & ndarray::ALIGNED) r \|= NPY_ARRAY_ALIGNED;
	38	if (f & ndarray::WRITEABLE) r \|= NPY_ARRAY_WRITEABLE;
7c673cae FG	39	return r;
	40	}
	41
	42	bool is_c_contiguous(std::vector<Py_intptr_t> const & shape,
	43	std::vector<Py_intptr_t> const & strides,
	44	int itemsize)
	45	{
	46	std::vector<Py_intptr_t>::const_reverse_iterator j = strides.rbegin();
	47	int total = itemsize;
	48	for (std::vector<Py_intptr_t>::const_reverse_iterator i = shape.rbegin(); i != shape.rend(); ++i, ++j)
	49	{
	50	if (total != *j) return false;
	51	total = (i);
	52	}
	53	return true;
	54	}
	55
	56	bool is_f_contiguous(std::vector<Py_intptr_t> const & shape,
	57	std::vector<Py_intptr_t> const & strides,
	58	int itemsize)
	59	{
	60	std::vector<Py_intptr_t>::const_iterator j = strides.begin();
	61	int total = itemsize;
	62	for (std::vector<Py_intptr_t>::const_iterator i = shape.begin(); i != shape.end(); ++i, ++j)
	63	{
	64	if (total != *j) return false;
	65	total = (i);
	66	}
	67	return true;
	68	}
	69
	70	bool is_aligned(std::vector<Py_intptr_t> const & strides,
	71	int itemsize)
	72	{
	73	for (std::vector<Py_intptr_t>::const_iterator i = strides.begin(); i != strides.end(); ++i)
	74	{
	75	if (*i % itemsize) return false;
	76	}
	77	return true;
	78	}
	79
	80	inline PyArray_Descr * incref_dtype(dtype const & dt)
	81	{
	82	Py_INCREF(dt.ptr());
	83	return reinterpret_cast<PyArray_Descr*>(dt.ptr());
	84	}
	85
	86	ndarray from_data_impl(void * data,
	87	dtype const & dt,
	88	python::object const & shape,
	89	python::object const & strides,
	90	python::object const & owner,
	91	bool writeable)
	92	{
	93	std::vector<Py_intptr_t> shape_(len(shape));
	94	std::vector<Py_intptr_t> strides_(len(strides));
	95	if (shape_.size() != strides_.size())
	96	{
	97	PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match.");
	98	python::throw_error_already_set();
	99	}
	100	for (std::size_t i = 0; i < shape_.size(); ++i)
	101	{
	102	shape_[i] = python::extract<Py_intptr_t>(shape[i]);
103	strides_[i] = python::extract<Py_intptr_t>(strides[i]);
104	}
105	return from_data_impl(data, dt, shape_, strides_, owner, writeable);
106	}
107
108	ndarray from_data_impl(void * data,
109	dtype const & dt,
110	std::vector<Py_intptr_t> const & shape,
111	std::vector<Py_intptr_t> const & strides,
112	python::object const & owner,
113	bool writeable)
114	{
115	if (shape.size() != strides.size())
116	{
117	PyErr_SetString(PyExc_ValueError, "Length of shape and strides arrays do not match.");
118	python::throw_error_already_set();
119	}
120	int itemsize = dt.get_itemsize();
121	int flags = 0;
b32b8144 FG	122	if (writeable) flags \|= NPY_ARRAY_WRITEABLE;
	123	if (is_c_contiguous(shape, strides, itemsize)) flags \|= NPY_ARRAY_C_CONTIGUOUS;
	124	if (is_f_contiguous(shape, strides, itemsize)) flags \|= NPY_ARRAY_F_CONTIGUOUS;
	125	if (is_aligned(strides, itemsize)) flags \|= NPY_ARRAY_ALIGNED;
7c673cae FG	126	ndarray r(python::detail::new_reference
	127	(PyArray_NewFromDescr(&PyArray_Type,
	128	incref_dtype(dt),
	129	shape.size(),
	130	const_cast<Py_intptr_t*>(&shape.front()),
	131	const_cast<Py_intptr_t*>(&strides.front()),
	132	data,
	133	flags,
	134	NULL)));
	135	r.set_base(owner);
	136	return r;
	137	}
	138
	139	} // namespace detail
	140
b32b8144 FG	141	namespace {
	142	int normalize_index(int n,int nlim) // wraps [-nlim:nlim) into [0:nlim), throw IndexError otherwise
	143	{
	144	if (n<0)
	145	n += nlim; // negative indices work backwards from end
	146	if (n < 0 \|\| n >= nlim)
	147	{
	148	PyErr_SetObject(PyExc_IndexError, Py_None);
	149	throw_error_already_set();
	150	}
	151	return n;
	152	}
	153	}
	154
	155	Py_intptr_t ndarray::shape(int n) const
	156	{
	157	return get_shape()[normalize_index(n,get_nd())];
	158	}
	159
	160	Py_intptr_t ndarray::strides(int n) const
	161	{
	162	return get_strides()[normalize_index(n,get_nd())];
	163	}
	164
7c673cae FG	165	ndarray ndarray::view(dtype const & dt) const
	166	{
	167	return ndarray(python::detail::new_reference
	168	(PyObject_CallMethod(this->ptr(), const_cast<char>("view"), const_cast<char>("O"), dt.ptr())));
	169	}
	170
	171	ndarray ndarray::astype(dtype const & dt) const
	172	{
	173	return ndarray(python::detail::new_reference
	174	(PyObject_CallMethod(this->ptr(), const_cast<char>("astype"), const_cast<char>("O"), dt.ptr())));
	175	}
	176
	177	ndarray ndarray::copy() const
	178	{
	179	return ndarray(python::detail::new_reference
	180	(PyObject_CallMethod(this->ptr(), const_cast<char>("copy"), const_cast<char>(""))));
	181	}
	182
	183	dtype ndarray::get_dtype() const
	184	{
	185	return dtype(python::detail::borrowed_reference(get_struct()->descr));
	186	}
	187
	188	python::object ndarray::get_base() const
	189	{
	190	if (get_struct()->base == NULL) return object();
	191	return python::object(python::detail::borrowed_reference(get_struct()->base));
	192	}
	193
	194	void ndarray::set_base(object const & base)
	195	{
	196	Py_XDECREF(get_struct()->base);
b32b8144	197	if (base.ptr())
7c673cae FG	198	{
	199	Py_INCREF(base.ptr());
	200	get_struct()->base = base.ptr();
	201	}
	202	else
	203	{
	204	get_struct()->base = NULL;
	205	}
	206	}
	207
	208	ndarray::bitflag ndarray::get_flags() const
	209	{
	210	return numpy::detail::numpy_to_bitflag(get_struct()->flags);
	211	}
	212
	213	ndarray ndarray::transpose() const
	214	{
	215	return ndarray(python::detail::new_reference
	216	(PyArray_Transpose(reinterpret_cast<PyArrayObject*>(this->ptr()), NULL)));
	217	}
	218
	219	ndarray ndarray::squeeze() const
	220	{
	221	return ndarray(python::detail::new_reference
	222	(PyArray_Squeeze(reinterpret_cast<PyArrayObject*>(this->ptr()))));
	223	}
	224
	225	ndarray ndarray::reshape(python::tuple const & shape) const
	226	{
	227	return ndarray(python::detail::new_reference
	228	(PyArray_Reshape(reinterpret_cast<PyArrayObject*>(this->ptr()), shape.ptr())));
	229	}
	230
	231	python::object ndarray::scalarize() const
	232	{
	233	Py_INCREF(ptr());
	234	return python::object(python::detail::new_reference(PyArray_Return(reinterpret_cast<PyArrayObject*>(ptr()))));
	235	}
	236
	237	ndarray zeros(python::tuple const & shape, dtype const & dt)
	238	{
	239	int nd = len(shape);
	240	boost::scoped_array<Py_intptr_t> dims(new Py_intptr_t[nd]);
	241	for (int n=0; n<nd; ++n) dims[n] = python::extract<Py_intptr_t>(shape[n]);
	242	return ndarray(python::detail::new_reference
	243	(PyArray_Zeros(nd, dims.get(), detail::incref_dtype(dt), 0)));
	244	}
	245
	246	ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt)
	247	{
	248	return ndarray(python::detail::new_reference
	249	(PyArray_Zeros(nd, const_cast<Py_intptr_t*>(shape), detail::incref_dtype(dt), 0)));
	250	}
	251
	252	ndarray empty(python::tuple const & shape, dtype const & dt)
	253	{
	254	int nd = len(shape);
	255	boost::scoped_array<Py_intptr_t> dims(new Py_intptr_t[nd]);
	256	for (int n=0; n<nd; ++n) dims[n] = python::extract<Py_intptr_t>(shape[n]);
	257	return ndarray(python::detail::new_reference
	258	(PyArray_Empty(nd, dims.get(), detail::incref_dtype(dt), 0)));
	259	}
	260
	261	ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt)
262	{
263	return ndarray(python::detail::new_reference
264	(PyArray_Empty(nd, const_cast<Py_intptr_t*>(shape), detail::incref_dtype(dt), 0)));
265	}
266
267	ndarray array(python::object const & obj)
268	{
269	return ndarray(python::detail::new_reference
b32b8144	270	(PyArray_FromAny(obj.ptr(), NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL)));
7c673cae FG	271	}
	272
	273	ndarray array(python::object const & obj, dtype const & dt)
	274	{
	275	return ndarray(python::detail::new_reference
b32b8144	276	(PyArray_FromAny(obj.ptr(), detail::incref_dtype(dt), 0, 0, NPY_ARRAY_ENSUREARRAY, NULL)));
7c673cae FG	277	}
	278
	279	ndarray from_object(python::object const & obj, dtype const & dt, int nd_min, int nd_max, ndarray::bitflag flags)
	280	{
	281	int requirements = detail::bitflag_to_numpy(flags);
	282	return ndarray(python::detail::new_reference
	283	(PyArray_FromAny(obj.ptr(),
	284	detail::incref_dtype(dt),
	285	nd_min, nd_max,
	286	requirements,
	287	NULL)));
	288	}
	289
	290	ndarray from_object(python::object const & obj, int nd_min, int nd_max, ndarray::bitflag flags)
	291	{
	292	int requirements = detail::bitflag_to_numpy(flags);
	293	return ndarray(python::detail::new_reference
	294	(PyArray_FromAny(obj.ptr(),
	295	NULL,
	296	nd_min, nd_max,
	297	requirements,
	298	NULL)));
	299	}
	300
	301	}}} // namespace boost::python::numpy