[Cython] Multidimensional indexing of C++ objects

[Stefan Behnel]

Hi Ian!

Ian Henriksen schrieb am 04.07.2015 um 00:43:
> I'm a GSOC student working to make a Cython API for DyND. DyND
> <https://github.com/libdynd/libdynd> is a relatively new n-dimensional
> array library in C++ that is based on NumPy. A full set of Python bindings
> (created using Cython) are provided as a separate package. The goal of my
> project is to make it so that DyND arrays can be used easily within Cython
> so that an n-dimensional array object can be used without any of the
> corresponding Python overhead.
> 
> Currently, there isn't a good way to assign to multidimensional slices
> within Cython. Since the indexing operator in C++ is limited to a single
> argument, we use the call operator to represent multidimensional indexing,
> and then use a proxy class to perform assignment to a slice.
> Currently, in C++, assigning to a slice along the second axis of a DyND
> array looks like this:
> 
> a(irange(), 1).vals() = 0;
> 
> Unfortunately, in Cython, only the index operator can be used for
> assignment, so following the C++ syntax isn't currently possible. Does
> anyone know of a good way to address this?

Just an idea, don't know how feasible this is, but we could allow inline
special methods in C++ class declarations that implement Python protocols.
Example:

    cdef extern from ...:
        cppclass Array2D:
           int operator[] except +
           int getItemAt(ssize_t x, ssize_t y) except +

           cdef inline __getitem__(self, Py_ssize_t x, Py_ssize_t y):
               return self.getItemAt(x, y)

    def test():
        cdef Array2D a
        return a[1, 2]

Cython could then translate an item access on an Array2D instance into the
corresponding special "method" call.

Drawbacks:

1) The example above would conflict with the C++ [] operator, so it would
be ambiguous which one is being used in Cython code. Not sure if there's a
use case for making both available to Cython code, but that would be
difficult to achieve if the need arises.

2) It doesn't solve the general problem of assigning to C++ expressions,
especially because it does not extend the syntax allowed by Cython which
would still limit what you can do in these fake special methods.

Regarding your proposals, I'd be happy if we could avoid adding syntax
support for assigning to function calls. And I agree that the cname
assignment hack is really just a big hack. It shouldn't be relied on.

Stefan