[Numpy-discussion] C-API for non-contiguous arrays
Thu Oct 25 06:18:13 CDT 2007
On 10/25/07, Oliver Kranz <firstname.lastname@example.org> wrote:
> I am working on a Python extension module using of the NumPy C-API. The
> extension module is an interface to an image processing and analysis
> library written in C++. The C++ functions are exported with
> boos::python. Currently I am implementing the support of
> three-dimensional data sets which can consume a huge amount of memory.
> The 3D data is stored in a numpy.ndarray. This array is passed to C++
> functions which do the calculations.
> In general, multi-dimensional arrays can be organized in memory in four
> different ways:
> 1. C order contiguous
> 2. Fortran order contiguous
> 3. C order non-contiguous
> 4. Fortran order non-contiguous
I believe that this is incorrect. Consider the following:
>>> import numpy as np
>>> a = np.arange(27).reshape(3,3,3)
(36, 12, 4)
(4, 12, 36)
(36, 4, 12)
I believe that the last transpose doesn't fit any of these four categories
and is simply discontiguous.
Am I right that the NumPy C-API can only distinguish between three ways
> the array is organized in memory? These are:
> 1. C order contiguous e.g. with PyArray_ISCONTIGUOUS(arr)
> 2. Fortran order contiguous e.g. with PyArray_ISFORTRAN(arr)
> 3. non-contiguous e.g. with !PyArray_ISCONTIGUOUS(arr) &&
> So there is no way to find out if a non-contiguous array has C order or
> Fortran order. The same holds for Python code e.g. by use of the flags.
> This is very important for me because I just want to avoid to copy every
> non-contiguous array into a contiguous array. This would be very
> inefficient. But I can't find an other solution than copying the array.
> Also the iterator provided by the C-API only loops over the array in C
> order. Even if the array is in Fortran non-contiguous order.
> Or are there just no Fortran order non-contiguous arrays? I think I can
> construct one.
> a = numpy.ndarray((3,4,5), order="F")
> b = a[:,1:2,:]
> Now, I think b's elements are organized in memory in Fortran
> non-contiguous order. But the flags only tell me that it is
> non-contiguous and not if it is in Fortran order or in C order. And if b
> would be passed to a C++ function it would not be possible to find out
> with the C-API if it is in Fortran order or in C order, too.
> Any ideas? Or do I always have to create contiguous arrays?
By Fortran and C-Order discontiguous, do you simply mean that the strides
are in increasing and decreasing order respectively? If so, you could check
for that without too much trouble.
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Numpy-discussion