ndarray::PyConverter< Array< T, N, C > > Struct Template Reference

A traits class providing Python conversion functions for Array. More...

#include <numpy.h>

Inheritance diagram for ndarray::PyConverter< Array< T, N, C > >:

Public Types
typedef Array< T, N, C >::Element	Element
typedef boost::remove_const < Element >::type	NonConst

Static Public Member Functions
static bool	fromPythonStage1 (PyPtr &p)
	Check if a Python object is convertible to T and optionally begin the conversion by replacing the input with an intermediate. More...
static bool	fromPythonStage2 (PyPtr const &input, Array< T, N, C > &output)
	Complete a Python to C++ conversion begun with fromPythonStage1(). More...
static PyObject *	toPython (Array< T, N, C > const &m, PyObject *owner=NULL)
	Create a numpy.ndarray from an ndarray::Array. More...
static PyTypeObject const *	getPyType ()
Static Public Member Functions inherited from ndarray::detail::PyConverterBase< Array< T, N, C > >
static bool	matches (PyObject *arg)
	Check if a Python object might be convertible to T. More...
static int	fromPython (PyObject *arg, Array< T, N, C > *output)
	Convert a Python object to a C++ object. More...

Detailed Description

template<typename T, int N, int C>
struct ndarray::PyConverter< Array< T, N, C > >

A traits class providing Python conversion functions for Array.

This specialization, for Array, adds addititional optional arguments to the toPython() conversion member function.

Definition at line 112 of file numpy.h.

Member Typedef Documentation

template<typename T , int N, int C>

typedef Array<T,N,C>::Element ndarray::PyConverter< Array< T, N, C > >::Element

Definition at line 113 of file numpy.h.

template<typename T , int N, int C>

typedef boost::remove_const<Element>::type ndarray::PyConverter< Array< T, N, C > >::NonConst

Definition at line 114 of file numpy.h.

Member Function Documentation

template<typename T , int N, int C>

static bool ndarray::PyConverter< Array< T, N, C > >::fromPythonStage1 ( PyPtr &  p )

inlinestatic

Check if a Python object is convertible to T and optionally begin the conversion by replacing the input with an intermediate.

Returns

true if a conversion may be possible, and false if it is not (with a Python exception set).

Parameters

p	On input, a Python object to be converted. On output, a Python object to be passed to fromPythonStage2().

Definition at line 124 of file numpy.h.

      {
        if (!PyArray_Check(p.get())) {
            PyErr_SetString(PyExc_TypeError, "numpy.ndarray argument required");
            return false;
        }
        int actualType = PyArray_TYPE(p.get());
        int requiredType = detail::NumpyTraits<NonConst>::getCode();
        if (actualType != requiredType) {
            PyErr_SetString(PyExc_ValueError, "numpy.ndarray argument has incorrect data type");
            return false;
        }
        if (PyArray_NDIM(p.get()) != N) {
            PyErr_SetString(PyExc_ValueError, "numpy.ndarray argument has incorrect number of dimensions");
            return false;
        }
        bool writeable = !boost::is_const<Element>::value;
        if (writeable && !(PyArray_FLAGS(p.get()) & NPY_WRITEABLE)) {
            PyErr_SetString(PyExc_TypeError, "numpy.ndarray argument must be writeable");
            return false;
        }
        if (C > 0) {
            int requiredStride = sizeof(Element);
            for (int i = 0; i < C; ++i) {
                int actualStride = PyArray_STRIDE(p.get(), N-i-1);
                if (actualStride != requiredStride) {
                    PyErr_SetString(
                        PyExc_ValueError,
                        "numpy.ndarray does not have enough row-major contiguous dimensions"
                    );
                    return false;
                }
                requiredStride *= PyArray_DIM(p.get(), N-i-1);
            }
        } else if (C < 0) {
            int requiredStride = sizeof(Element);
            for (int i = 0; i < -C; ++i) {
                int actualStride = PyArray_STRIDE(p.get(), i);
                if (actualStride != requiredStride) {
                    PyErr_SetString(
                        PyExc_ValueError,
                        "numpy.ndarray does not have enough column-major contiguous dimensions"
                    );
                    return false;
                }
                requiredStride *= PyArray_DIM(p.get(), i);
            }
        }
        return true;
    }

template<typename T , int N, int C>

static bool ndarray::PyConverter< Array< T, N, C > >::fromPythonStage2 ( PyPtr const &  input, Array< T, N, C > &  output  )

inlinestatic

Complete a Python to C++ conversion begun with fromPythonStage1().

The copy will be shallow if possible and deep if necessary to meet the data type and contiguousness requirements. If a non-const array is required, the copy will always be shallow; if this is not possible, ValueError will be raised.

The output Array's shared_ptr owner attribute will own a reference to the numpy array that ultimately owns the data (either the original or the copy).

Returns

true on success, false on failure (with a Python exception set).

Parameters

input	Result of fromPythonStage1().
output	Reference to existing output C++ object.

Definition at line 191 of file numpy.h.

      {
        if (!(PyArray_FLAGS(input.get()) & NPY_ALIGNED)) {
            PyErr_SetString(PyExc_ValueError, "unaligned arrays cannot be converted to C++");
            return false;
        }
        Vector<int,N> shape;
        Vector<int,N> strides;
        std::copy(PyArray_DIMS(input.get()), PyArray_DIMS(input.get()) + N, shape.begin());
        std::copy(PyArray_STRIDES(input.get()), PyArray_STRIDES(input.get()) + N , strides.begin());
        for (int i = 0; i < N; ++i) strides[i] /= sizeof(Element);
        output = external(
            reinterpret_cast<Element*>(PyArray_DATA(input.get())),
            shape, strides, input
        );
        return true;
    }

template<typename T , int N, int C>

static PyTypeObject const* ndarray::PyConverter< Array< T, N, C > >::getPyType ( )

inlinestatic

Definition at line 262 of file numpy.h.

{ return &PyArray_Type; }

template<typename T , int N, int C>

static PyObject* ndarray::PyConverter< Array< T, N, C > >::toPython ( Array< T, N, C > const &  m, PyObject *  owner = NULL  )

inlinestatic

Create a numpy.ndarray from an ndarray::Array.

The Array will be shallow-copied with reference counting if either m.getManager() is not empty or the optional owner argument is supplied; otherwise a deep copy will be made.

Returns

a new Python object, or NULL on failure (with a Python exception set).

Parameters

m	The input Array object.
owner	A Python object that owns the memory in the Array. If NULL, one will be constructed from m.getManager().

Definition at line 221 of file numpy.h.

      {
        int flags = NPY_ALIGNED;
        if (C==N) flags |= NPY_C_CONTIGUOUS;
        bool writeable = !boost::is_const<Element>::value;
        if (writeable) flags |= NPY_WRITEABLE;
        npy_intp outShape[N];
        npy_intp outStrides[N];
        Vector<int,N> inShape = m.getShape();
        Vector<int,N> inStrides = m.getStrides();
        std::copy(inShape.begin(), inShape.end(), outShape);
        for (int i = 0; i < N; ++i) outStrides[i] = inStrides[i] * sizeof(Element);
        PyPtr array(
            PyArray_New(
                &PyArray_Type, N, outShape, detail::NumpyTraits<NonConst>::getCode(),
                outStrides, const_cast<NonConst*>(m.getData()), sizeof(Element), flags, NULL
            ),
            false
        );
        if (!array) return NULL;
        if (!m.getManager() && owner == NULL) {
            flags = NPY_CARRAY_RO | NPY_ENSURECOPY | NPY_C_CONTIGUOUS;
            if (writeable) flags |= NPY_WRITEABLE;
            PyPtr r = PyArray_FROM_OF(array.get(),flags);
            if (!r) return NULL;
            array.swap(r);
        } else {
            if (owner != NULL) {
                Py_INCREF(owner);
            } else {
                owner = PyCObject_FromVoidPtr(new Manager::Ptr(m.getManager()), detail::destroyCObject);
            }
            reinterpret_cast<PyArrayObject*>(array.get())->base = owner;
        }
        Py_INCREF(array.get());
        return PyArray_Return(reinterpret_cast<PyArrayObject*>(array.get()));
    }

---

The documentation for this struct was generated from the following file:

• /home/lsstsw/stack/Linux64/ndarray/10.1+37/include/ndarray/swig/numpy.h