path: root/contrib/tools/cython/Cython/Utility/MemoryView.pyx

#################### View.MemoryView #################### 
 
# This utility provides cython.array and cython.view.memoryview 
 
from __future__ import absolute_import
 
cimport cython

# from cpython cimport ... 
cdef extern from "Python.h": 
    int PyIndex_Check(object) 
    object PyLong_FromVoidPtr(void *) 
 
cdef extern from "pythread.h": 
    ctypedef void *PyThread_type_lock 
 
    PyThread_type_lock PyThread_allocate_lock() 
    void PyThread_free_lock(PyThread_type_lock) 
    int PyThread_acquire_lock(PyThread_type_lock, int mode) nogil 
    void PyThread_release_lock(PyThread_type_lock) nogil 
 
cdef extern from "<string.h>":
    void *memset(void *b, int c, size_t len) 
 
cdef extern from *: 
    int __Pyx_GetBuffer(object, Py_buffer *, int) except -1 
    void __Pyx_ReleaseBuffer(Py_buffer *) 
 
    ctypedef struct PyObject 
    ctypedef Py_ssize_t Py_intptr_t 
    void Py_INCREF(PyObject *) 
    void Py_DECREF(PyObject *) 
 
    void* PyMem_Malloc(size_t n) 
    void PyMem_Free(void *p) 
    void* PyObject_Malloc(size_t n)
    void PyObject_Free(void *p)
 
    cdef struct __pyx_memoryview "__pyx_memoryview_obj": 
        Py_buffer view 
        PyObject *obj 
        __Pyx_TypeInfo *typeinfo 
 
    ctypedef struct {{memviewslice_name}}: 
        __pyx_memoryview *memview 
        char *data 
        Py_ssize_t shape[{{max_dims}}] 
        Py_ssize_t strides[{{max_dims}}] 
        Py_ssize_t suboffsets[{{max_dims}}] 
 
    void __PYX_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil) 
    void __PYX_XDEC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil) 
 
    ctypedef struct __pyx_buffer "Py_buffer": 
        PyObject *obj 
 
    PyObject *Py_None 
 
    cdef enum: 
        PyBUF_C_CONTIGUOUS, 
        PyBUF_F_CONTIGUOUS, 
        PyBUF_ANY_CONTIGUOUS 
        PyBUF_FORMAT 
        PyBUF_WRITABLE 
        PyBUF_STRIDES 
        PyBUF_INDIRECT 
        PyBUF_ND
        PyBUF_RECORDS 
        PyBUF_RECORDS_RO
 
    ctypedef struct __Pyx_TypeInfo: 
        pass 
 
    cdef object capsule "__pyx_capsule_create" (void *p, char *sig) 
    cdef int __pyx_array_getbuffer(PyObject *obj, Py_buffer view, int flags) 
    cdef int __pyx_memoryview_getbuffer(PyObject *obj, Py_buffer view, int flags) 
 
cdef extern from *: 
    ctypedef int __pyx_atomic_int 
    {{memviewslice_name}} slice_copy_contig "__pyx_memoryview_copy_new_contig"( 
                                 __Pyx_memviewslice *from_mvs, 
                                 char *mode, int ndim, 
                                 size_t sizeof_dtype, int contig_flag, 
                                 bint dtype_is_object) nogil except * 
    bint slice_is_contig "__pyx_memviewslice_is_contig" ( 
                            {{memviewslice_name}} mvs, char order, int ndim) nogil
    bint slices_overlap "__pyx_slices_overlap" ({{memviewslice_name}} *slice1, 
                                                {{memviewslice_name}} *slice2, 
                                                int ndim, size_t itemsize) nogil 
 
 
cdef extern from "<stdlib.h>":
    void *malloc(size_t) nogil 
    void free(void *) nogil 
    void *memcpy(void *dest, void *src, size_t n) nogil 
 
 
 
 
# 
### cython.array class 
# 
 
@cname("__pyx_array") 
cdef class array: 
 
    cdef: 
        char *data 
        Py_ssize_t len 
        char *format 
        int ndim 
        Py_ssize_t *_shape 
        Py_ssize_t *_strides 
        Py_ssize_t itemsize 
        unicode mode  # FIXME: this should have been a simple 'char' 
        bytes _format 
        void (*callback_free_data)(void *data) 
        # cdef object _memview 
        cdef bint free_data 
        cdef bint dtype_is_object 
 
    def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, 
                  mode="c", bint allocate_buffer=True): 
 
        cdef int idx 
        cdef Py_ssize_t i, dim 
        cdef PyObject **p 
 
        self.ndim = <int> len(shape) 
        self.itemsize = itemsize 
 
        if not self.ndim: 
            raise ValueError("Empty shape tuple for cython.array") 
 
        if itemsize <= 0: 
            raise ValueError("itemsize <= 0 for cython.array") 
 
        if not isinstance(format, bytes):
            format = format.encode('ASCII')
        self._format = format  # keep a reference to the byte string 
        self.format = self._format 
 
        # use single malloc() for both shape and strides 
        self._shape = <Py_ssize_t *> PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
        self._strides = self._shape + self.ndim 
 
        if not self._shape: 
            raise MemoryError("unable to allocate shape and strides.") 
 
        # cdef Py_ssize_t dim, stride 
        for idx, dim in enumerate(shape): 
            if dim <= 0: 
                raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) 
            self._shape[idx] = dim 
 
        cdef char order 
        if mode == 'fortran': 
            order = b'F' 
            self.mode = u'fortran' 
        elif mode == 'c': 
            order = b'C' 
            self.mode = u'c' 
        else: 
            raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) 
 
        self.len = fill_contig_strides_array(self._shape, self._strides, 
                                             itemsize, self.ndim, order) 
 
        self.free_data = allocate_buffer 
        self.dtype_is_object = format == b'O' 
        if allocate_buffer: 
            # use malloc() for backwards compatibility 
            # in case external code wants to change the data pointer 
            self.data = <char *>malloc(self.len) 
            if not self.data: 
                raise MemoryError("unable to allocate array data.") 
 
            if self.dtype_is_object: 
                p = <PyObject **> self.data 
                for i in range(self.len / itemsize): 
                    p[i] = Py_None 
                    Py_INCREF(Py_None) 
 
    @cname('getbuffer') 
    def __getbuffer__(self, Py_buffer *info, int flags): 
        cdef int bufmode = -1 
        if self.mode == u"c": 
            bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS 
        elif self.mode == u"fortran": 
            bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS 
        if not (flags & bufmode): 
            raise ValueError("Can only create a buffer that is contiguous in memory.") 
        info.buf = self.data 
        info.len = self.len 
        info.ndim = self.ndim 
        info.shape = self._shape 
        info.strides = self._strides 
        info.suboffsets = NULL 
        info.itemsize = self.itemsize 
        info.readonly = 0 
 
        if flags & PyBUF_FORMAT: 
            info.format = self.format 
        else: 
            info.format = NULL 
 
        info.obj = self 
 
    __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") 
 
    def __dealloc__(array self): 
        if self.callback_free_data != NULL: 
            self.callback_free_data(self.data) 
        elif self.free_data: 
            if self.dtype_is_object: 
                refcount_objects_in_slice(self.data, self._shape, 
                                          self._strides, self.ndim, False) 
            free(self.data) 
        PyObject_Free(self._shape)
 
    @property
    def memview(self):
        return self.get_memview()
 
    @cname('get_memview')
    cdef get_memview(self):
        flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
        return  memoryview(self, flags, self.dtype_is_object)
 
    def __len__(self):
        return self._shape[0]

    def __getattr__(self, attr): 
        return getattr(self.memview, attr) 
 
    def __getitem__(self, item): 
        return self.memview[item] 
 
    def __setitem__(self, item, value): 
        self.memview[item] = value 
 
 
@cname("__pyx_array_new") 
cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, 
                          char *mode, char *buf): 
    cdef array result 
 
    if buf == NULL: 
        result = array(shape, itemsize, format, mode.decode('ASCII')) 
    else: 
        result = array(shape, itemsize, format, mode.decode('ASCII'), 
                       allocate_buffer=False) 
        result.data = buf 
 
    return result 
 
 
# 
### Memoryview constants and cython.view.memoryview class 
# 
 
# Disable generic_contiguous, as it makes trouble verifying contiguity: 
#   - 'contiguous' or '::1' means the dimension is contiguous with dtype 
#   - 'indirect_contiguous' means a contiguous list of pointers 
#   - dtype contiguous must be contiguous in the first or last dimension 
#     from the start, or from the dimension following the last indirect dimension 
# 
#   e.g. 
#           int[::indirect_contiguous, ::contiguous, :] 
# 
#   is valid (list of pointers to 2d fortran-contiguous array), but 
# 
#           int[::generic_contiguous, ::contiguous, :] 
# 
#   would mean you'd have assert dimension 0 to be indirect (and pointer contiguous) at runtime. 
#   So it doesn't bring any performance benefit, and it's only confusing. 
 
@cname('__pyx_MemviewEnum') 
cdef class Enum(object): 
    cdef object name 
    def __init__(self, name): 
        self.name = name 
    def __repr__(self): 
        return self.name 
 
cdef generic = Enum("<strided and direct or indirect>") 
cdef strided = Enum("<strided and direct>") # default 
cdef indirect = Enum("<strided and indirect>") 
# Disable generic_contiguous, as it is a troublemaker 
#cdef generic_contiguous = Enum("<contiguous and direct or indirect>") 
cdef contiguous = Enum("<contiguous and direct>") 
cdef indirect_contiguous = Enum("<contiguous and indirect>") 
 
# 'follow' is implied when the first or last axis is ::1 
 
 
@cname('__pyx_align_pointer') 
cdef void *align_pointer(void *memory, size_t alignment) nogil: 
    "Align pointer memory on a given boundary" 
    cdef Py_intptr_t aligned_p = <Py_intptr_t> memory 
    cdef size_t offset 
 
    with cython.cdivision(True): 
        offset = aligned_p % alignment 
 
    if offset > 0: 
        aligned_p += alignment - offset 
 
    return <void *> aligned_p 
 

# pre-allocate thread locks for reuse
## note that this could be implemented in a more beautiful way in "normal" Cython,
## but this code gets merged into the user module and not everything works there.
DEF THREAD_LOCKS_PREALLOCATED = 8
cdef int __pyx_memoryview_thread_locks_used = 0
cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
    PyThread_allocate_lock(),
]


@cname('__pyx_memoryview') 
cdef class memoryview(object): 
 
    cdef object obj 
    cdef object _size 
    cdef object _array_interface 
    cdef PyThread_type_lock lock 
    # the following array will contain a single __pyx_atomic int with 
    # suitable alignment 
    cdef __pyx_atomic_int acquisition_count[2] 
    cdef __pyx_atomic_int *acquisition_count_aligned_p 
    cdef Py_buffer view 
    cdef int flags 
    cdef bint dtype_is_object 
    cdef __Pyx_TypeInfo *typeinfo 
 
    def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): 
        self.obj = obj 
        self.flags = flags 
        if type(self) is memoryview or obj is not None: 
            __Pyx_GetBuffer(obj, &self.view, flags) 
            if <PyObject *> self.view.obj == NULL: 
                (<__pyx_buffer *> &self.view).obj = Py_None 
                Py_INCREF(Py_None) 
 
        global __pyx_memoryview_thread_locks_used
        if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
            self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
            __pyx_memoryview_thread_locks_used += 1
        if self.lock is NULL:
            self.lock = PyThread_allocate_lock()
            if self.lock is NULL:
                raise MemoryError
 
        if flags & PyBUF_FORMAT: 
            self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
        else: 
            self.dtype_is_object = dtype_is_object 
 
        self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( 
                  <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int)) 
        self.typeinfo = NULL 
 
    def __dealloc__(memoryview self): 
        if self.obj is not None: 
            __Pyx_ReleaseBuffer(&self.view) 
        elif (<__pyx_buffer *> &self.view).obj == Py_None:
            # Undo the incref in __cinit__() above.
            (<__pyx_buffer *> &self.view).obj = NULL
            Py_DECREF(Py_None)
 
        cdef int i
        global __pyx_memoryview_thread_locks_used
        if self.lock != NULL: 
            for i in range(__pyx_memoryview_thread_locks_used):
                if __pyx_memoryview_thread_locks[i] is self.lock:
                    __pyx_memoryview_thread_locks_used -= 1
                    if i != __pyx_memoryview_thread_locks_used:
                        __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
                            __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
                    break
            else:
                PyThread_free_lock(self.lock)
 
    cdef char *get_item_pointer(memoryview self, object index) except NULL: 
        cdef Py_ssize_t dim 
        cdef char *itemp = <char *> self.view.buf 
 
        for dim, idx in enumerate(index): 
            itemp = pybuffer_index(&self.view, itemp, idx, dim) 
 
        return itemp 
 
    #@cname('__pyx_memoryview_getitem') 
    def __getitem__(memoryview self, object index): 
        if index is Ellipsis: 
            return self 
 
        have_slices, indices = _unellipsify(index, self.view.ndim) 
 
        cdef char *itemp 
        if have_slices: 
            return memview_slice(self, indices) 
        else: 
            itemp = self.get_item_pointer(indices) 
            return self.convert_item_to_object(itemp) 
 
    def __setitem__(memoryview self, object index, object value): 
        if self.view.readonly:
            raise TypeError("Cannot assign to read-only memoryview")

        have_slices, index = _unellipsify(index, self.view.ndim) 
 
        if have_slices: 
            obj = self.is_slice(value) 
            if obj: 
                self.setitem_slice_assignment(self[index], obj) 
            else: 
                self.setitem_slice_assign_scalar(self[index], value) 
        else: 
            self.setitem_indexed(index, value) 
 
    cdef is_slice(self, obj): 
        if not isinstance(obj, memoryview): 
            try: 
                obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
                                 self.dtype_is_object) 
            except TypeError: 
                return None 
 
        return obj 
 
    cdef setitem_slice_assignment(self, dst, src): 
        cdef {{memviewslice_name}} dst_slice 
        cdef {{memviewslice_name}} src_slice 
 
        memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], 
                                 get_slice_from_memview(dst, &dst_slice)[0], 
                                 src.ndim, dst.ndim, self.dtype_is_object) 
 
    cdef setitem_slice_assign_scalar(self, memoryview dst, value): 
        cdef int array[128] 
        cdef void *tmp = NULL 
        cdef void *item 
 
        cdef {{memviewslice_name}} *dst_slice 
        cdef {{memviewslice_name}} tmp_slice 
        dst_slice = get_slice_from_memview(dst, &tmp_slice) 
 
        if <size_t>self.view.itemsize > sizeof(array): 
            tmp = PyMem_Malloc(self.view.itemsize) 
            if tmp == NULL: 
                raise MemoryError 
            item = tmp 
        else: 
            item = <void *> array 
 
        try: 
            if self.dtype_is_object: 
                (<PyObject **> item)[0] = <PyObject *> value 
            else: 
                self.assign_item_from_object(<char *> item, value) 
 
            # It would be easy to support indirect dimensions, but it's easier 
            # to disallow :) 
            if self.view.suboffsets != NULL: 
                assert_direct_dimensions(self.view.suboffsets, self.view.ndim) 
            slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, 
                                item, self.dtype_is_object) 
        finally: 
            PyMem_Free(tmp) 
 
    cdef setitem_indexed(self, index, value): 
        cdef char *itemp = self.get_item_pointer(index) 
        self.assign_item_from_object(itemp, value) 
 
    cdef convert_item_to_object(self, char *itemp): 
        """Only used if instantiated manually by the user, or if Cython doesn't 
        know how to convert the type""" 
        import struct 
        cdef bytes bytesitem 
        # Do a manual and complete check here instead of this easy hack 
        bytesitem = itemp[:self.view.itemsize] 
        try: 
            result = struct.unpack(self.view.format, bytesitem) 
        except struct.error: 
            raise ValueError("Unable to convert item to object") 
        else: 
            if len(self.view.format) == 1: 
                return result[0] 
            return result 
 
    cdef assign_item_from_object(self, char *itemp, object value): 
        """Only used if instantiated manually by the user, or if Cython doesn't 
        know how to convert the type""" 
        import struct 
        cdef char c 
        cdef bytes bytesvalue 
        cdef Py_ssize_t i 
 
        if isinstance(value, tuple): 
            bytesvalue = struct.pack(self.view.format, *value) 
        else: 
            bytesvalue = struct.pack(self.view.format, value) 
 
        for i, c in enumerate(bytesvalue): 
            itemp[i] = c 
 
    @cname('getbuffer') 
    def __getbuffer__(self, Py_buffer *info, int flags): 
        if flags & PyBUF_WRITABLE and self.view.readonly:
            raise ValueError("Cannot create writable memory view from read-only memoryview")

        if flags & PyBUF_ND:
            info.shape = self.view.shape 
        else: 
            info.shape = NULL 
 
        if flags & PyBUF_STRIDES: 
            info.strides = self.view.strides 
        else: 
            info.strides = NULL 
 
        if flags & PyBUF_INDIRECT: 
            info.suboffsets = self.view.suboffsets 
        else: 
            info.suboffsets = NULL 
 
        if flags & PyBUF_FORMAT: 
            info.format = self.view.format 
        else: 
            info.format = NULL 
 
        info.buf = self.view.buf 
        info.ndim = self.view.ndim 
        info.itemsize = self.view.itemsize 
        info.len = self.view.len 
        info.readonly = self.view.readonly
        info.obj = self 
 
    __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") 
 
    # Some properties that have the same semantics as in NumPy
    @property
    def T(self):
        cdef _memoryviewslice result = memoryview_copy(self)
        transpose_memslice(&result.from_slice)
        return result
 
    @property
    def base(self):
        return self.obj
 
    @property
    def shape(self):
        return tuple([length for length in self.view.shape[:self.view.ndim]])
 
    @property
    def strides(self):
        if self.view.strides == NULL:
            # Note: we always ask for strides, so if this is not set it's a bug
            raise ValueError("Buffer view does not expose strides")
 
        return tuple([stride for stride in self.view.strides[:self.view.ndim]])
 
    @property
    def suboffsets(self):
        if self.view.suboffsets == NULL:
            return (-1,) * self.view.ndim
 
        return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
 
    @property
    def ndim(self):
        return self.view.ndim
 
    @property
    def itemsize(self):
        return self.view.itemsize
 
    @property
    def nbytes(self):
        return self.size * self.view.itemsize
 
    @property
    def size(self):
        if self._size is None:
            result = 1
 
            for length in self.view.shape[:self.view.ndim]:
                result *= length
 
            self._size = result
 
        return self._size
 
    def __len__(self): 
        if self.view.ndim >= 1: 
            return self.view.shape[0] 
 
        return 0 
 
    def __repr__(self): 
        return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__, 
                                               id(self)) 
 
    def __str__(self): 
        return "<MemoryView of %r object>" % (self.base.__class__.__name__,) 
 
    # Support the same attributes as memoryview slices 
    def is_c_contig(self): 
        cdef {{memviewslice_name}} *mslice 
        cdef {{memviewslice_name}} tmp 
        mslice = get_slice_from_memview(self, &tmp) 
        return slice_is_contig(mslice[0], 'C', self.view.ndim)
 
    def is_f_contig(self): 
        cdef {{memviewslice_name}} *mslice 
        cdef {{memviewslice_name}} tmp 
        mslice = get_slice_from_memview(self, &tmp) 
        return slice_is_contig(mslice[0], 'F', self.view.ndim)
 
    def copy(self): 
        cdef {{memviewslice_name}} mslice 
        cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS 
 
        slice_copy(self, &mslice) 
        mslice = slice_copy_contig(&mslice, "c", self.view.ndim, 
                                   self.view.itemsize, 
                                   flags|PyBUF_C_CONTIGUOUS, 
                                   self.dtype_is_object) 
 
        return memoryview_copy_from_slice(self, &mslice) 
 
    def copy_fortran(self): 
        cdef {{memviewslice_name}} src, dst 
        cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS 
 
        slice_copy(self, &src) 
        dst = slice_copy_contig(&src, "fortran", self.view.ndim, 
                                self.view.itemsize, 
                                flags|PyBUF_F_CONTIGUOUS, 
                                self.dtype_is_object) 
 
        return memoryview_copy_from_slice(self, &dst) 
 
 
@cname('__pyx_memoryview_new') 
cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): 
    cdef memoryview result = memoryview(o, flags, dtype_is_object) 
    result.typeinfo = typeinfo 
    return result 
 
@cname('__pyx_memoryview_check') 
cdef inline bint memoryview_check(object o): 
    return isinstance(o, memoryview) 
 
cdef tuple _unellipsify(object index, int ndim): 
    """ 
    Replace all ellipses with full slices and fill incomplete indices with 
    full slices. 
    """ 
    if not isinstance(index, tuple): 
        tup = (index,) 
    else: 
        tup = index 
 
    result = [] 
    have_slices = False 
    seen_ellipsis = False 
    for idx, item in enumerate(tup): 
        if item is Ellipsis: 
            if not seen_ellipsis: 
                result.extend([slice(None)] * (ndim - len(tup) + 1)) 
                seen_ellipsis = True 
            else: 
                result.append(slice(None)) 
            have_slices = True 
        else: 
            if not isinstance(item, slice) and not PyIndex_Check(item): 
                raise TypeError("Cannot index with type '%s'" % type(item)) 
 
            have_slices = have_slices or isinstance(item, slice) 
            result.append(item) 
 
    nslices = ndim - len(result) 
    if nslices: 
        result.extend([slice(None)] * nslices) 
 
    return have_slices or nslices, tuple(result) 
 
cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): 
    for suboffset in suboffsets[:ndim]:
        if suboffset >= 0:
            raise ValueError("Indirect dimensions not supported") 
 
# 
### Slicing a memoryview 
# 
 
@cname('__pyx_memview_slice') 
cdef memoryview memview_slice(memoryview memview, object indices): 
    cdef int new_ndim = 0, suboffset_dim = -1, dim 
    cdef bint negative_step 
    cdef {{memviewslice_name}} src, dst 
    cdef {{memviewslice_name}} *p_src 
 
    # dst is copied by value in memoryview_fromslice -- initialize it 
    # src is never copied 
    memset(&dst, 0, sizeof(dst)) 
 
    cdef _memoryviewslice memviewsliceobj 
 
    assert memview.view.ndim > 0 
 
    if isinstance(memview, _memoryviewslice): 
        memviewsliceobj = memview 
        p_src = &memviewsliceobj.from_slice 
    else: 
        slice_copy(memview, &src) 
        p_src = &src 
 
    # Note: don't use variable src at this point 
    # SubNote: we should be able to declare variables in blocks... 
 
    # memoryview_fromslice() will inc our dst slice 
    dst.memview = p_src.memview 
    dst.data = p_src.data 
 
    # Put everything in temps to avoid this bloody warning: 
    # "Argument evaluation order in C function call is undefined and 
    #  may not be as expected" 
    cdef {{memviewslice_name}} *p_dst = &dst 
    cdef int *p_suboffset_dim = &suboffset_dim 
    cdef Py_ssize_t start, stop, step 
    cdef bint have_start, have_stop, have_step 
 
    for dim, index in enumerate(indices): 
        if PyIndex_Check(index): 
            slice_memviewslice( 
                p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], 
                dim, new_ndim, p_suboffset_dim, 
                index, 0, 0, # start, stop, step 
                0, 0, 0, # have_{start,stop,step} 
                False) 
        elif index is None: 
            p_dst.shape[new_ndim] = 1 
            p_dst.strides[new_ndim] = 0 
            p_dst.suboffsets[new_ndim] = -1 
            new_ndim += 1 
        else: 
            start = index.start or 0 
            stop = index.stop or 0 
            step = index.step or 0 
 
            have_start = index.start is not None 
            have_stop = index.stop is not None 
            have_step = index.step is not None 
 
            slice_memviewslice( 
                p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], 
                dim, new_ndim, p_suboffset_dim, 
                start, stop, step, 
                have_start, have_stop, have_step, 
                True) 
            new_ndim += 1 
 
    if isinstance(memview, _memoryviewslice): 
        return memoryview_fromslice(dst, new_ndim, 
                                    memviewsliceobj.to_object_func, 
                                    memviewsliceobj.to_dtype_func, 
                                    memview.dtype_is_object) 
    else: 
        return memoryview_fromslice(dst, new_ndim, NULL, NULL, 
                                    memview.dtype_is_object) 
 
 
# 
### Slicing in a single dimension of a memoryviewslice 
# 
 
cdef extern from "<stdlib.h>":
    void abort() nogil 
    void printf(char *s, ...) nogil 
 
cdef extern from "<stdio.h>":
    ctypedef struct FILE 
    FILE *stderr 
    int fputs(char *s, FILE *stream) 
 
cdef extern from "pystate.h": 
    void PyThreadState_Get() nogil 
 
    # These are not actually nogil, but we check for the GIL before calling them 
    void PyErr_SetString(PyObject *type, char *msg) nogil 
    PyObject *PyErr_Format(PyObject *exc, char *msg, ...) nogil 
 
@cname('__pyx_memoryview_slice_memviewslice') 
cdef int slice_memviewslice( 
        {{memviewslice_name}} *dst, 
        Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, 
        int dim, int new_ndim, int *suboffset_dim, 
        Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, 
        int have_start, int have_stop, int have_step, 
        bint is_slice) nogil except -1: 
    """ 
    Create a new slice dst given slice src. 
 
    dim             - the current src dimension (indexing will make dimensions 
                                                 disappear) 
    new_dim         - the new dst dimension 
    suboffset_dim   - pointer to a single int initialized to -1 to keep track of 
                      where slicing offsets should be added 
    """ 
 
    cdef Py_ssize_t new_shape 
    cdef bint negative_step 
 
    if not is_slice: 
        # index is a normal integer-like index 
        if start < 0: 
            start += shape 
        if not 0 <= start < shape: 
            _err_dim(IndexError, "Index out of bounds (axis %d)", dim) 
    else: 
        # index is a slice 
        negative_step = have_step != 0 and step < 0 
 
        if have_step and step == 0: 
            _err_dim(ValueError, "Step may not be zero (axis %d)", dim) 
 
        # check our bounds and set defaults 
        if have_start: 
            if start < 0: 
                start += shape 
                if start < 0: 
                    start = 0 
            elif start >= shape: 
                if negative_step: 
                    start = shape - 1 
                else: 
                    start = shape 
        else: 
            if negative_step: 
                start = shape - 1 
            else: 
                start = 0 
 
        if have_stop: 
            if stop < 0: 
                stop += shape 
                if stop < 0: 
                    stop = 0 
            elif stop > shape: 
                stop = shape 
        else: 
            if negative_step: 
                stop = -1 
            else: 
                stop = shape 
 
        if not have_step: 
            step = 1 
 
        # len = ceil( (stop - start) / step ) 
        with cython.cdivision(True): 
            new_shape = (stop - start) // step 
 
            if (stop - start) - step * new_shape: 
                new_shape += 1 
 
        if new_shape < 0: 
            new_shape = 0 
 
        # shape/strides/suboffsets 
        dst.strides[new_ndim] = stride * step 
        dst.shape[new_ndim] = new_shape 
        dst.suboffsets[new_ndim] = suboffset 
 
    # Add the slicing or idexing offsets to the right suboffset or base data * 
    if suboffset_dim[0] < 0: 
        dst.data += start * stride 
    else: 
        dst.suboffsets[suboffset_dim[0]] += start * stride 
 
    if suboffset >= 0: 
        if not is_slice: 
            if new_ndim == 0: 
                dst.data = (<char **> dst.data)[0] + suboffset 
            else: 
                _err_dim(IndexError, "All dimensions preceding dimension %d " 
                                     "must be indexed and not sliced", dim) 
        else: 
            suboffset_dim[0] = new_ndim 
 
    return 0 
 
# 
### Index a memoryview 
# 
@cname('__pyx_pybuffer_index') 
cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, 
                          Py_ssize_t dim) except NULL: 
    cdef Py_ssize_t shape, stride, suboffset = -1 
    cdef Py_ssize_t itemsize = view.itemsize 
    cdef char *resultp 
 
    if view.ndim == 0: 
        shape = view.len / itemsize 
        stride = itemsize 
    else: 
        shape = view.shape[dim] 
        stride = view.strides[dim] 
        if view.suboffsets != NULL: 
            suboffset = view.suboffsets[dim] 
 
    if index < 0: 
        index += view.shape[dim] 
        if index < 0: 
            raise IndexError("Out of bounds on buffer access (axis %d)" % dim) 
 
    if index >= shape: 
        raise IndexError("Out of bounds on buffer access (axis %d)" % dim) 
 
    resultp = bufp + index * stride 
    if suboffset >= 0: 
        resultp = (<char **> resultp)[0] + suboffset 
 
    return resultp 
 
# 
### Transposing a memoryviewslice 
# 
@cname('__pyx_memslice_transpose') 
cdef int transpose_memslice({{memviewslice_name}} *memslice) nogil except 0: 
    cdef int ndim = memslice.memview.view.ndim 
 
    cdef Py_ssize_t *shape = memslice.shape 
    cdef Py_ssize_t *strides = memslice.strides 
 
    # reverse strides and shape 
    cdef int i, j 
    for i in range(ndim / 2): 
        j = ndim - 1 - i 
        strides[i], strides[j] = strides[j], strides[i] 
        shape[i], shape[j] = shape[j], shape[i] 
 
        if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: 
            _err(ValueError, "Cannot transpose memoryview with indirect dimensions") 
 
    return 1 
 
# 
### Creating new memoryview objects from slices and memoryviews 
# 
@cname('__pyx_memoryviewslice') 
cdef class _memoryviewslice(memoryview): 
    "Internal class for passing memoryview slices to Python" 
 
    # We need this to keep our shape/strides/suboffset pointers valid 
    cdef {{memviewslice_name}} from_slice 
    # We need this only to print it's class' name 
    cdef object from_object 
 
    cdef object (*to_object_func)(char *) 
    cdef int (*to_dtype_func)(char *, object) except 0 
 
    def __dealloc__(self): 
        __PYX_XDEC_MEMVIEW(&self.from_slice, 1) 
 
    cdef convert_item_to_object(self, char *itemp): 
        if self.to_object_func != NULL: 
            return self.to_object_func(itemp) 
        else: 
            return memoryview.convert_item_to_object(self, itemp) 
 
    cdef assign_item_from_object(self, char *itemp, object value): 
        if self.to_dtype_func != NULL: 
            self.to_dtype_func(itemp, value) 
        else: 
            memoryview.assign_item_from_object(self, itemp, value) 
 
    @property
    def base(self):
        return self.from_object
 
    __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") 
 
 
@cname('__pyx_memoryview_fromslice') 
cdef memoryview_fromslice({{memviewslice_name}} memviewslice, 
                          int ndim, 
                          object (*to_object_func)(char *), 
                          int (*to_dtype_func)(char *, object) except 0, 
                          bint dtype_is_object): 
 
    cdef _memoryviewslice result 
 
    if <PyObject *> memviewslice.memview == Py_None: 
        return None 
 
    # assert 0 < ndim <= memviewslice.memview.view.ndim, ( 
    #                 ndim, memviewslice.memview.view.ndim) 
 
    result = _memoryviewslice(None, 0, dtype_is_object) 
 
    result.from_slice = memviewslice 
    __PYX_INC_MEMVIEW(&memviewslice, 1) 
 
    result.from_object = (<memoryview> memviewslice.memview).base 
    result.typeinfo = memviewslice.memview.typeinfo 
 
    result.view = memviewslice.memview.view 
    result.view.buf = <void *> memviewslice.data 
    result.view.ndim = ndim 
    (<__pyx_buffer *> &result.view).obj = Py_None 
    Py_INCREF(Py_None) 
 
    if (<memoryview>memviewslice.memview).flags & PyBUF_WRITABLE:
        result.flags = PyBUF_RECORDS
    else:
        result.flags = PyBUF_RECORDS_RO
 
    result.view.shape = <Py_ssize_t *> result.from_slice.shape 
    result.view.strides = <Py_ssize_t *> result.from_slice.strides 
 
    # only set suboffsets if actually used, otherwise set to NULL to improve compatibility
    result.view.suboffsets = NULL
    for suboffset in result.from_slice.suboffsets[:ndim]:
        if suboffset >= 0:
            result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
            break

    result.view.len = result.view.itemsize 
    for length in result.view.shape[:ndim]:
        result.view.len *= length
 
    result.to_object_func = to_object_func 
    result.to_dtype_func = to_dtype_func 
 
    return result 
 
@cname('__pyx_memoryview_get_slice_from_memoryview') 
cdef {{memviewslice_name}} *get_slice_from_memview(memoryview memview, 
                                                   {{memviewslice_name}} *mslice) except NULL:
    cdef _memoryviewslice obj 
    if isinstance(memview, _memoryviewslice): 
        obj = memview 
        return &obj.from_slice 
    else: 
        slice_copy(memview, mslice) 
        return mslice 
 
@cname('__pyx_memoryview_slice_copy') 
cdef void slice_copy(memoryview memview, {{memviewslice_name}} *dst): 
    cdef int dim 
    cdef (Py_ssize_t*) shape, strides, suboffsets 
 
    shape = memview.view.shape 
    strides = memview.view.strides 
    suboffsets = memview.view.suboffsets 
 
    dst.memview = <__pyx_memoryview *> memview 
    dst.data = <char *> memview.view.buf 
 
    for dim in range(memview.view.ndim): 
        dst.shape[dim] = shape[dim] 
        dst.strides[dim] = strides[dim] 
        dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
 
@cname('__pyx_memoryview_copy_object') 
cdef memoryview_copy(memoryview memview): 
    "Create a new memoryview object" 
    cdef {{memviewslice_name}} memviewslice 
    slice_copy(memview, &memviewslice) 
    return memoryview_copy_from_slice(memview, &memviewslice) 
 
@cname('__pyx_memoryview_copy_object_from_slice') 
cdef memoryview_copy_from_slice(memoryview memview, {{memviewslice_name}} *memviewslice): 
    """ 
    Create a new memoryview object from a given memoryview object and slice. 
    """ 
    cdef object (*to_object_func)(char *) 
    cdef int (*to_dtype_func)(char *, object) except 0 
 
    if isinstance(memview, _memoryviewslice): 
        to_object_func = (<_memoryviewslice> memview).to_object_func 
        to_dtype_func = (<_memoryviewslice> memview).to_dtype_func 
    else: 
        to_object_func = NULL 
        to_dtype_func = NULL 
 
    return memoryview_fromslice(memviewslice[0], memview.view.ndim, 
                                to_object_func, to_dtype_func, 
                                memview.dtype_is_object) 
 
 
# 
### Copy the contents of a memoryview slices 
# 
cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: 
    if arg < 0: 
        return -arg 
    else: 
        return arg 
 
@cname('__pyx_get_best_slice_order') 
cdef char get_best_order({{memviewslice_name}} *mslice, int ndim) nogil: 
    """ 
    Figure out the best memory access order for a given slice. 
    """ 
    cdef int i 
    cdef Py_ssize_t c_stride = 0 
    cdef Py_ssize_t f_stride = 0 
 
    for i in range(ndim - 1, -1, -1): 
        if mslice.shape[i] > 1: 
            c_stride = mslice.strides[i] 
            break 
 
    for i in range(ndim): 
        if mslice.shape[i] > 1: 
            f_stride = mslice.strides[i] 
            break 
 
    if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): 
        return 'C' 
    else: 
        return 'F' 
 
@cython.cdivision(True) 
cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, 
                                   char *dst_data, Py_ssize_t *dst_strides, 
                                   Py_ssize_t *src_shape, Py_ssize_t *dst_shape, 
                                   int ndim, size_t itemsize) nogil: 
    # Note: src_extent is 1 if we're broadcasting 
    # dst_extent always >= src_extent as we don't do reductions 
    cdef Py_ssize_t i 
    cdef Py_ssize_t src_extent = src_shape[0] 
    cdef Py_ssize_t dst_extent = dst_shape[0] 
    cdef Py_ssize_t src_stride = src_strides[0] 
    cdef Py_ssize_t dst_stride = dst_strides[0] 
 
    if ndim == 1: 
       if (src_stride > 0 and dst_stride > 0 and 
           <size_t> src_stride == itemsize == <size_t> dst_stride): 
           memcpy(dst_data, src_data, itemsize * dst_extent) 
       else: 
           for i in range(dst_extent): 
               memcpy(dst_data, src_data, itemsize) 
               src_data += src_stride 
               dst_data += dst_stride 
    else: 
        for i in range(dst_extent): 
            _copy_strided_to_strided(src_data, src_strides + 1, 
                                     dst_data, dst_strides + 1, 
                                     src_shape + 1, dst_shape + 1, 
                                     ndim - 1, itemsize) 
            src_data += src_stride 
            dst_data += dst_stride 
 
cdef void copy_strided_to_strided({{memviewslice_name}} *src, 
                                  {{memviewslice_name}} *dst, 
                                  int ndim, size_t itemsize) nogil: 
    _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, 
                             src.shape, dst.shape, ndim, itemsize) 
 
@cname('__pyx_memoryview_slice_get_size') 
cdef Py_ssize_t slice_get_size({{memviewslice_name}} *src, int ndim) nogil: 
    "Return the size of the memory occupied by the slice in number of bytes" 
    cdef Py_ssize_t shape, size = src.memview.view.itemsize
 
    for shape in src.shape[:ndim]:
        size *= shape
 
    return size 
 
@cname('__pyx_fill_contig_strides_array') 
cdef Py_ssize_t fill_contig_strides_array( 
                Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, 
                int ndim, char order) nogil: 
    """ 
    Fill the strides array for a slice with C or F contiguous strides. 
    This is like PyBuffer_FillContiguousStrides, but compatible with py < 2.6 
    """ 
    cdef int idx 
 
    if order == 'F': 
        for idx in range(ndim): 
            strides[idx] = stride 
            stride *= shape[idx]
    else: 
        for idx in range(ndim - 1, -1, -1): 
            strides[idx] = stride 
            stride *= shape[idx]
 
    return stride 
 
@cname('__pyx_memoryview_copy_data_to_temp') 
cdef void *copy_data_to_temp({{memviewslice_name}} *src, 
                             {{memviewslice_name}} *tmpslice, 
                             char order, 
                             int ndim) nogil except NULL: 
    """ 
    Copy a direct slice to temporary contiguous memory. The caller should free 
    the result when done. 
    """ 
    cdef int i 
    cdef void *result 
 
    cdef size_t itemsize = src.memview.view.itemsize 
    cdef size_t size = slice_get_size(src, ndim) 
 
    result = malloc(size) 
    if not result: 
        _err(MemoryError, NULL) 
 
    # tmpslice[0] = src 
    tmpslice.data = <char *> result 
    tmpslice.memview = src.memview 
    for i in range(ndim): 
        tmpslice.shape[i] = src.shape[i] 
        tmpslice.suboffsets[i] = -1 
 
    fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, 
                              ndim, order) 
 
    # We need to broadcast strides again 
    for i in range(ndim): 
        if tmpslice.shape[i] == 1: 
            tmpslice.strides[i] = 0 
 
    if slice_is_contig(src[0], order, ndim):
        memcpy(result, src.data, size) 
    else: 
        copy_strided_to_strided(src, tmpslice, ndim, itemsize) 
 
    return result 
 
# Use 'with gil' functions and avoid 'with gil' blocks, as the code within the blocks 
# has temporaries that need the GIL to clean up 
@cname('__pyx_memoryview_err_extents') 
cdef int _err_extents(int i, Py_ssize_t extent1, 
                             Py_ssize_t extent2) except -1 with gil: 
    raise ValueError("got differing extents in dimension %d (got %d and %d)" % 
                                                        (i, extent1, extent2)) 
 
@cname('__pyx_memoryview_err_dim') 
cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: 
    raise error(msg.decode('ascii') % dim) 
 
@cname('__pyx_memoryview_err') 
cdef int _err(object error, char *msg) except -1 with gil: 
    if msg != NULL: 
        raise error(msg.decode('ascii')) 
    else: 
        raise error 
 
@cname('__pyx_memoryview_copy_contents') 
cdef int memoryview_copy_contents({{memviewslice_name}} src, 
                                  {{memviewslice_name}} dst, 
                                  int src_ndim, int dst_ndim, 
                                  bint dtype_is_object) nogil except -1: 
    """ 
    Copy memory from slice src to slice dst. 
    Check for overlapping memory and verify the shapes. 
    """ 
    cdef void *tmpdata = NULL 
    cdef size_t itemsize = src.memview.view.itemsize 
    cdef int i 
    cdef char order = get_best_order(&src, src_ndim) 
    cdef bint broadcasting = False 
    cdef bint direct_copy = False 
    cdef {{memviewslice_name}} tmp 
 
    if src_ndim < dst_ndim: 
        broadcast_leading(&src, src_ndim, dst_ndim) 
    elif dst_ndim < src_ndim: 
        broadcast_leading(&dst, dst_ndim, src_ndim) 
 
    cdef int ndim = max(src_ndim, dst_ndim) 
 
    for i in range(ndim): 
        if src.shape[i] != dst.shape[i]: 
            if src.shape[i] == 1: 
                broadcasting = True 
                src.strides[i] = 0 
            else: 
                _err_extents(i, dst.shape[i], src.shape[i]) 
 
        if src.suboffsets[i] >= 0: 
            _err_dim(ValueError, "Dimension %d is not direct", i) 
 
    if slices_overlap(&src, &dst, ndim, itemsize): 
        # slices overlap, copy to temp, copy temp to dst 
        if not slice_is_contig(src, order, ndim):
            order = get_best_order(&dst, ndim) 
 
        tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) 
        src = tmp 
 
    if not broadcasting: 
        # See if both slices have equal contiguity, in that case perform a 
        # direct copy. This only works when we are not broadcasting. 
        if slice_is_contig(src, 'C', ndim):
            direct_copy = slice_is_contig(dst, 'C', ndim)
        elif slice_is_contig(src, 'F', ndim):
            direct_copy = slice_is_contig(dst, 'F', ndim)
 
        if direct_copy: 
            # Contiguous slices with same order 
            refcount_copying(&dst, dtype_is_object, ndim, False) 
            memcpy(dst.data, src.data, slice_get_size(&src, ndim)) 
            refcount_copying(&dst, dtype_is_object, ndim, True) 
            free(tmpdata) 
            return 0 
 
    if order == 'F' == get_best_order(&dst, ndim): 
        # see if both slices have Fortran order, transpose them to match our 
        # C-style indexing order 
        transpose_memslice(&src) 
        transpose_memslice(&dst) 
 
    refcount_copying(&dst, dtype_is_object, ndim, False) 
    copy_strided_to_strided(&src, &dst, ndim, itemsize) 
    refcount_copying(&dst, dtype_is_object, ndim, True) 
 
    free(tmpdata) 
    return 0 
 
@cname('__pyx_memoryview_broadcast_leading') 
cdef void broadcast_leading({{memviewslice_name}} *mslice,
                            int ndim, 
                            int ndim_other) nogil: 
    cdef int i 
    cdef int offset = ndim_other - ndim 
 
    for i in range(ndim - 1, -1, -1): 
        mslice.shape[i + offset] = mslice.shape[i]
        mslice.strides[i + offset] = mslice.strides[i]
        mslice.suboffsets[i + offset] = mslice.suboffsets[i]
 
    for i in range(offset): 
        mslice.shape[i] = 1
        mslice.strides[i] = mslice.strides[0]
        mslice.suboffsets[i] = -1
 
# 
### Take care of refcounting the objects in slices. Do this separately from any copying,
### to minimize acquiring the GIL 
# 
 
@cname('__pyx_memoryview_refcount_copying') 
cdef void refcount_copying({{memviewslice_name}} *dst, bint dtype_is_object, 
                           int ndim, bint inc) nogil: 
    # incref or decref the objects in the destination slice if the dtype is 
    # object 
    if dtype_is_object: 
        refcount_objects_in_slice_with_gil(dst.data, dst.shape, 
                                           dst.strides, ndim, inc) 
 
@cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') 
cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, 
                                             Py_ssize_t *strides, int ndim, 
                                             bint inc) with gil: 
    refcount_objects_in_slice(data, shape, strides, ndim, inc) 
 
@cname('__pyx_memoryview_refcount_objects_in_slice') 
cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, 
                                    Py_ssize_t *strides, int ndim, bint inc): 
    cdef Py_ssize_t i 
 
    for i in range(shape[0]): 
        if ndim == 1: 
            if inc: 
                Py_INCREF((<PyObject **> data)[0]) 
            else: 
                Py_DECREF((<PyObject **> data)[0]) 
        else: 
            refcount_objects_in_slice(data, shape + 1, strides + 1, 
                                      ndim - 1, inc) 
 
        data += strides[0] 
 
# 
### Scalar to slice assignment 
# 
@cname('__pyx_memoryview_slice_assign_scalar') 
cdef void slice_assign_scalar({{memviewslice_name}} *dst, int ndim, 
                              size_t itemsize, void *item, 
                              bint dtype_is_object) nogil: 
    refcount_copying(dst, dtype_is_object, ndim, False) 
    _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, 
                         itemsize, item) 
    refcount_copying(dst, dtype_is_object, ndim, True) 
 
 
@cname('__pyx_memoryview__slice_assign_scalar') 
cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, 
                              Py_ssize_t *strides, int ndim, 
                              size_t itemsize, void *item) nogil: 
    cdef Py_ssize_t i 
    cdef Py_ssize_t stride = strides[0] 
    cdef Py_ssize_t extent = shape[0] 
 
    if ndim == 1: 
        for i in range(extent): 
            memcpy(data, item, itemsize) 
            data += stride 
    else: 
        for i in range(extent): 
            _slice_assign_scalar(data, shape + 1, strides + 1, 
                                ndim - 1, itemsize, item) 
            data += stride 
 
 
############### BufferFormatFromTypeInfo ############### 
cdef extern from *: 
    ctypedef struct __Pyx_StructField 
 
    cdef enum: 
        __PYX_BUF_FLAGS_PACKED_STRUCT 
        __PYX_BUF_FLAGS_INTEGER_COMPLEX 
 
    ctypedef struct __Pyx_TypeInfo: 
      char* name 
      __Pyx_StructField* fields 
      size_t size 
      size_t arraysize[8] 
      int ndim 
      char typegroup 
      char is_unsigned 
      int flags 
 
    ctypedef struct __Pyx_StructField: 
      __Pyx_TypeInfo* type 
      char* name 
      size_t offset 
 
    ctypedef struct __Pyx_BufFmt_StackElem: 
      __Pyx_StructField* field 
      size_t parent_offset 
 
    #ctypedef struct __Pyx_BufFmt_Context: 
    #  __Pyx_StructField root 
      __Pyx_BufFmt_StackElem* head 
 
    struct __pyx_typeinfo_string: 
        char string[3] 
 
    __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *) 
 
 
@cname('__pyx_format_from_typeinfo') 
cdef bytes format_from_typeinfo(__Pyx_TypeInfo *type): 
    cdef __Pyx_StructField *field 
    cdef __pyx_typeinfo_string fmt 
    cdef bytes part, result 
 
    if type.typegroup == 'S': 
        assert type.fields != NULL
        assert type.fields.type != NULL
 
        if type.flags & __PYX_BUF_FLAGS_PACKED_STRUCT: 
            alignment = b'^' 
        else: 
            alignment = b'' 
 
        parts = [b"T{"] 
        field = type.fields 
 
        while field.type: 
            part = format_from_typeinfo(field.type) 
            parts.append(part + b':' + field.name + b':') 
            field += 1 
 
        result = alignment.join(parts) + b'}' 
    else: 
        fmt = __Pyx_TypeInfoToFormat(type) 
        if type.arraysize[0]: 
            extents = [unicode(type.arraysize[i]) for i in range(type.ndim)] 
            result = (u"(%s)" % u','.join(extents)).encode('ascii') + fmt.string 
        else: 
            result = fmt.string 
 
    return result