Cython 3.2.0__cp39-abi3-win32.whl

Cython/Utility/UFuncs.pyx

@@ -0,0 +1,50 @@
+##################### UFuncDefinition ######################
+
+cdef extern from *:
+    ctypedef int npy_intp
+    struct PyObject
+    PyObject* __Pyx_NewRef(object)
+
+# variable names have to come from tempita to avoid duplication
+@cname("{{func_cname}}")
+cdef void {{func_cname}}(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data) except * {{"nogil" if will_be_called_without_gil else ""}}:
+    cdef npy_intp i
+    cdef npy_intp n = dimensions[0]
+    {{for idx, tn_tp in enumerate(in_types)}}
+    cdef char* in_{{idx}} = args[{{idx}}]
+    cdef {{tn_tp[0]}} cast_in_{{idx}}
+    {{endfor}}
+    {{for idx, tn_tp in enumerate(out_types)}}
+    cdef char* out_{{idx}} = args[{{idx+len(in_types)}}]
+    cdef {{tn_tp[0]}} cast_out_{{idx}}
+    {{endfor}}
+    {{for idx in range(len(out_types)+len(in_types))}}
+    cdef npy_intp step_{{idx}} = steps[{{idx}}]
+    {{endfor}}
+
+    {{"with gil" if (not nogil and will_be_called_without_gil) else "if True"}}:
+        for i in range(n):
+            {{for idx, tn_tp in enumerate(in_types)}}
+            {{if tn_tp[1].is_pyobject}}
+            cast_in_{{idx}} = (<{{tn_tp[0]}}>(<void**>in_{{idx}})[0])
+            {{else}}
+            cast_in_{{idx}} = (<{{tn_tp[0]}}*>in_{{idx}})[0]
+            {{endif}}
+            {{endfor}}
+
+            {{", ".join("cast_out_{}".format(idx) for idx in range(len(out_types)))}} = \
+                {{inline_func_call}}({{", ".join("cast_in_{}".format(idx) for idx in range(len(in_types)))}})
+
+            {{for idx, tn_tp in enumerate(out_types)}}
+            {{if tn_tp[1].is_pyobject}}
+            (<void**>out_{{idx}})[0] = <void*>__Pyx_NewRef(cast_out_{{idx}})
+            {{else}}
+            (<{{tn_tp[0]}}*>out_{{idx}})[0] = cast_out_{{idx}}
+            {{endif}}
+            {{endfor}}
+            {{for idx in range(len(in_types))}}
+            in_{{idx}} += step_{{idx}}
+            {{endfor}}
+            {{for idx in range(len(out_types))}}
+            out_{{idx}} += step_{{idx+len(in_types)}}
+            {{endfor}}

Cython/Utility/UFuncs_C.c

@@ -0,0 +1,89 @@
+///////////////////////// UFuncsInit.proto /////////////////////////
+//@proto_block: utility_code_proto_before_types
+
+#include <numpy/arrayobject.h>
+#include <numpy/ufuncobject.h>
+
+// account for change in type of arguments to PyUFuncGenericFunction in Numpy 1.19.x
+// Unfortunately we can only test against Numpy version 1.20.x since it wasn't marked
+// as an API break. Therefore, I'm "solving" the issue by casting function pointer types
+// on lower Numpy versions.
+#if NPY_API_VERSION >= 0x0000000e // Numpy 1.20.x
+#define __PYX_PYUFUNCGENERICFUNCTION_CAST(x) x
+#else
+#define __PYX_PYUFUNCGENERICFUNCTION_CAST(x) (PyUFuncGenericFunction)x
+#endif
+
+/////////////////////// UFuncTypeHandling.proto //////////////
+
+#define __PYX_GET_NPY_COMPLEX_TYPE(tp) \
+    sizeof(tp) == sizeof(npy_cfloat) ? NPY_CFLOAT : \
+    sizeof(tp) == sizeof(npy_cdouble) ? NPY_CDOUBLE : \
+    sizeof(tp) == sizeof(npy_clongdouble) ? NPY_CLONGDOUBLE : NPY_NOTYPE
+
+#define __PYX_GET_NPY_FLOAT_TYPE(tp) \
+    sizeof(tp) == sizeof(npy_float) ? NPY_FLOAT : \
+    sizeof(tp) == sizeof(npy_double) ? NPY_DOUBLE : \
+    sizeof(tp) == sizeof(npy_longdouble) ? NPY_LONGDOUBLE : NPY_NOTYPE
+
+#define __PYX_GET_NPY_UINT_TYPE(tp) \
+    sizeof(tp) == 1 ? NPY_UINT8 : \
+    sizeof(tp) == 2 ? NPY_UINT16 : \
+    sizeof(tp) == 4 ? NPY_UINT32 : \
+    sizeof(tp) == 8 ? NPY_UINT64 : NPY_NOTYPE
+
+#define __PYX_GET_NPY_SINT_TYPE(tp) \
+    sizeof(tp) == 1 ? NPY_INT8 : \
+    sizeof(tp) == 2 ? NPY_INT16 : \
+    sizeof(tp) == 4 ? NPY_INT32 : \
+    sizeof(tp) == 8 ? NPY_INT64 : NPY_NOTYPE
+
+#define __PYX_GET_NPY_INT_TYPE(tp) ( \
+    (((tp)-1) > (tp)0) ? \
+        (__PYX_GET_NPY_UINT_TYPE(tp)) : \
+        (__PYX_GET_NPY_SINT_TYPE(tp)) )
+
+/////////////////////// UFuncTypedef.proto ///////////////////
+//@requires: UFuncTypeHandling
+
+enum {
+    /*
+      Deduce what to tell Numpy about the extern typedef '{{type_cname}}'
+    */
+    __Pyx_typedef_ufunc_{{type_substituted_cname}} = {{macro_name}}({{type_cname}}),
+
+    /* Validation:
+       If the line below is failing then you are using the extern typedef
+       '{{type_cname}}' as a parameter in a ufunc and Cython can't work out
+       how to map the type to a Numpy type.
+    */
+    __Pyx_typedef_ufunc_validation_{{type_substituted_cname}} =
+        1 / (int)(__Pyx_typedef_ufunc_{{type_substituted_cname}} - NPY_NOTYPE)
+};
+
+/////////////////////// UFuncConsts.proto ////////////////////
+
+// getter functions because we can't forward-declare arrays
+static PyUFuncGenericFunction* {{ufunc_funcs_name}}(void); /* proto */
+static char* {{ufunc_types_name}}(void); /* proto */
+static void* {{ufunc_data_name}}[] = {NULL};  /* always null */
+
+/////////////////////// UFuncConsts /////////////////////////
+
+static PyUFuncGenericFunction* {{ufunc_funcs_name}}(void) {
+    static PyUFuncGenericFunction arr[] = {
+        {{for loop, cname in looper(func_cnames)}}
+        __PYX_PYUFUNCGENERICFUNCTION_CAST(&{{cname}}){{if not loop.last}},{{endif}}
+        {{endfor}}
+    };
+    return arr;
+}
+
+static char* {{ufunc_types_name}}(void) {
+    static char arr[] = {
+        {{for loop, tp in looper(type_constants)}}
+        {{tp}}{{if not loop.last}},{{endif}}
+        {{endfor}}
+    };
+    return arr;
+}

Cython/Utility/__init__.py

@@ -0,0 +1,28 @@
+def pylong_join(count, digits_ptr='digits', join_type='unsigned long'):
+    """
+    Generate an unrolled shift-then-or loop over the first 'count' digits.
+    Assumes that they fit into 'join_type'.
+
+    (((d[2] << n) | d[1]) << n) | d[0]
+    """
+    return ('(' * (count * 2) + ' | '.join(
+        "(%s)%s[%d])%s)" % (join_type, digits_ptr, _i, " << PyLong_SHIFT" if _i else '')
+        for _i in range(count-1, -1, -1)))
+
+
+# although it could potentially make use of data independence,
+# this implementation is a bit slower than the simpler one above
+def _pylong_join(count, digits_ptr='digits', join_type='unsigned long'):
+    """
+    Generate an or-ed series of shifts for the first 'count' digits.
+    Assumes that they fit into 'join_type'.
+
+    (d[2] << 2*n) | (d[1] << 1*n) | d[0]
+    """
+    def shift(n):
+        # avoid compiler warnings for overly large shifts that will be discarded anyway
+        return " << (%d * PyLong_SHIFT < 8 * sizeof(%s) ? %d * PyLong_SHIFT : 0)" % (n, join_type, n) if n else ''
+
+    return '(%s)' % ' | '.join(
+        "(((%s)%s[%d])%s)" % (join_type, digits_ptr, i, shift(i))
+        for i in range(count-1, -1, -1))

Cython/Utility/arrayarray.h

@@ -0,0 +1,167 @@
+/////////////// ArrayAPI.proto ///////////////
+
+// arrayarray.h
+//
+//    Artificial C-API for Python's <array.array> type,
+//    used by array.pxd
+//
+//    last changes: 2009-05-15 rk
+//                  2012-05-02 andreasvc
+//                  (see revision control)
+//
+
+#ifndef _ARRAYARRAY_H
+#define _ARRAYARRAY_H
+
+// These two forward declarations are explicitly handled in the type
+// declaration code, as including them here is too late for cython-defined
+// types to use them.
+// struct arrayobject;
+// typedef struct arrayobject arrayobject;
+
+// All possible arraydescr values are defined in the vector "descriptors"
+// below.  That's defined later because the appropriate get and set
+// functions aren't visible yet.
+typedef struct arraydescr {
+    int typecode;
+    int itemsize;
+    PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
+    int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
+    char *formats;
+} arraydescr;
+
+typedef union {
+    char *ob_item;
+    float *as_floats;
+    double *as_doubles;
+    int *as_ints;
+    unsigned int *as_uints;
+    unsigned char *as_uchars;
+    signed char *as_schars;
+    char *as_chars;
+    unsigned long *as_ulongs;
+    long *as_longs;
+    unsigned long long *as_ulonglongs;
+    long long *as_longlongs;
+    short *as_shorts;
+    unsigned short *as_ushorts;
+    // Don't use Py_UNICODE ourselves in the union. This avoids deprecation warnings 
+    // for anyone who uses array.array but doesn't use this field.
+    #if PY_VERSION_HEX >= 0x030d0000
+    Py_DEPRECATED(3.13) 
+    #endif
+        wchar_t *as_pyunicodes;
+    void *as_voidptr;
+} __Pyx_data_union;
+
+struct arrayobject {
+    PyObject_HEAD
+    Py_ssize_t ob_size;
+    __Pyx_data_union data;
+    Py_ssize_t allocated;
+    struct arraydescr *ob_descr;
+    PyObject *weakreflist; /* List of weak references */
+    int ob_exports;  /* Number of exported buffers */
+};
+
+#ifndef NO_NEWARRAY_INLINE
+//  fast creation of a new array
+static CYTHON_INLINE PyObject * newarrayobject(PyTypeObject *type, Py_ssize_t size,
+    struct arraydescr *descr) {
+    arrayobject *op;
+    size_t nbytes;
+
+    if (size < 0) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
+    nbytes = size * descr->itemsize;
+    // Check for overflow
+    if (nbytes / descr->itemsize != (size_t)size) {
+        return PyErr_NoMemory();
+    }
+    op = (arrayobject *) type->tp_alloc(type, 0);
+    if (op == NULL) {
+        return NULL;
+    }
+    op->ob_descr = descr;
+    op->allocated = size;
+    op->weakreflist = NULL;
+    __Pyx_SET_SIZE(op, size);
+    if (size <= 0) {
+        op->data.ob_item = NULL;
+    }
+    else {
+        op->data.ob_item = PyMem_NEW(char, nbytes);
+        if (op->data.ob_item == NULL) {
+            Py_DECREF(op);
+            return PyErr_NoMemory();
+        }
+    }
+    return (PyObject *) op;
+}
+#else
+PyObject* newarrayobject(PyTypeObject *type, Py_ssize_t size,
+    struct arraydescr *descr);
+#endif /* ifndef NO_NEWARRAY_INLINE */
+
+static CYTHON_INLINE __Pyx_data_union __Pyx_PyArray_Data(arrayobject *self) {
+#if CYTHON_COMPILING_IN_GRAAL
+    __Pyx_data_union data;
+    data.ob_item = GraalPyArray_Data((PyObject*)self);
+    return data;
+#else
+    return self->data;
+#endif
+}
+
+// fast resize (reallocation to the point)
+// not designed for filing small increments (but for fast opaque array apps)
+static CYTHON_INLINE int resize(arrayobject *self, Py_ssize_t n) {
+#if CYTHON_COMPILING_IN_GRAAL
+    return GraalPyArray_Resize((PyObject*)self, n);
+#else
+    void *items = (void*) self->data.ob_item;
+    PyMem_Resize(items, char, (size_t)(n * self->ob_descr->itemsize));
+    if (items == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    self->data.ob_item = (char*) items;
+    __Pyx_SET_SIZE(self, n);
+    self->allocated = n;
+    return 0;
+#endif
+}
+
+// suitable for small increments; over allocation 50% ;
+static CYTHON_INLINE int resize_smart(arrayobject *self, Py_ssize_t n) {
+#if CYTHON_COMPILING_IN_GRAAL
+    return GraalPyArray_Resize((PyObject*)self, n);
+#else
+    void *items = (void*) self->data.ob_item;
+    Py_ssize_t newsize;
+    if (n < self->allocated && n*4 > self->allocated) {
+        __Pyx_SET_SIZE(self, n);
+        return 0;
+    }
+    newsize = n + (n / 2) + 1;
+    if (newsize <= n) {   /* overflow */
+        PyErr_NoMemory();
+        return -1;
+    }
+    PyMem_Resize(items, char, (size_t)(newsize * self->ob_descr->itemsize));
+    if (items == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    self->data.ob_item = (char*) items;
+    __Pyx_SET_SIZE(self, n);
+    self->allocated = newsize;
+    return 0;
+#endif
+}
+
+#endif
+/* _ARRAYARRAY_H */