From f9c13116f562a018ece86c8549329e87bfe4e43d Mon Sep 17 00:00:00 2001 From: Charles Harris Date: Tue, 21 Jul 2020 14:52:29 -0600 Subject: [PATCH 01/13] REL: prepare 1.19.x for further development --- doc/source/release.rst | 1 + doc/source/release/1.19.2-notes.rst | 45 +++++++++++++++++++++++++++++ pavement.py | 2 +- setup.py | 4 +-- 4 files changed, 49 insertions(+), 3 deletions(-) create mode 100644 doc/source/release/1.19.2-notes.rst diff --git a/doc/source/release.rst b/doc/source/release.rst index 18e8b200d71f..a1d17d36422b 100644 --- a/doc/source/release.rst +++ b/doc/source/release.rst @@ -5,6 +5,7 @@ Release Notes .. toctree:: :maxdepth: 3 + 1.19.2 1.19.1 1.19.0 1.18.4 diff --git a/doc/source/release/1.19.2-notes.rst b/doc/source/release/1.19.2-notes.rst new file mode 100644 index 000000000000..eda1976f5a7a --- /dev/null +++ b/doc/source/release/1.19.2-notes.rst @@ -0,0 +1,45 @@ +.. currentmodule:: numpy + +========================== +NumPy 1.19.2 Release Notes +========================== + + +Highlights +========== + + +New functions +============= + + +Deprecations +============ + + +Future Changes +============== + + +Expired deprecations +==================== + + +Compatibility notes +=================== + + +C API changes +============= + + +New Features +============ + + +Improvements +============ + + +Changes +======= diff --git a/pavement.py b/pavement.py index a8551e2a3149..928fda3a6c8d 100644 --- a/pavement.py +++ b/pavement.py @@ -37,7 +37,7 @@ #----------------------------------- # Path to the release notes -RELEASE_NOTES = 'doc/source/release/1.19.1-notes.rst' +RELEASE_NOTES = 'doc/source/release/1.19.2-notes.rst' #------------------------------------------------------- diff --git a/setup.py b/setup.py index cb435acbcc3b..ab391a4fe2ae 100755 --- a/setup.py +++ b/setup.py @@ -55,8 +55,8 @@ MAJOR = 1 MINOR = 19 -MICRO = 1 -ISRELEASED = True +MICRO = 2 +ISRELEASED = False VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO) From cf077022ed5d5d5e68e55dce2b68bfa352a6545b Mon Sep 17 00:00:00 2001 From: Charles Harris Date: Mon, 27 Jul 2020 17:11:57 -0600 Subject: [PATCH 02/13] TST: Change aarch64 to arm64 in travis.yml. TravisCI doesn't recognize aarch64 and was falling back to x86_64. --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index e019495fb852..b863660f7569 100644 --- a/.travis.yml +++ b/.travis.yml @@ -121,7 +121,7 @@ jobs: - python: 3.7 os: linux - arch: aarch64 + arch: arm64 env: # use OpenBLAS build, not system ATLAS - DOWNLOAD_OPENBLAS=1 From 4932c9e7316a0dbc909a402cf6de95de656e7f12 Mon Sep 17 00:00:00 2001 From: Zac-HD Date: Thu, 16 Jul 2020 14:54:36 +1000 Subject: [PATCH 03/13] Configure hypothesis for np.test() --- numpy/_pytesttester.py | 11 +++++++++++ numpy/conftest.py | 15 ++++++++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/numpy/_pytesttester.py b/numpy/_pytesttester.py index ca86aeb22a08..8a33be5256b8 100644 --- a/numpy/_pytesttester.py +++ b/numpy/_pytesttester.py @@ -125,6 +125,9 @@ def __call__(self, label='fast', verbose=1, extra_argv=None, import pytest import warnings + # Imported after pytest to enable assertion rewriting + import hypothesis + module = sys.modules[self.module_name] module_path = os.path.abspath(module.__path__[0]) @@ -187,6 +190,14 @@ def __call__(self, label='fast', verbose=1, extra_argv=None, pytest_args += ["--pyargs"] + list(tests) + # This configuration is picked up by numpy.conftest, and ensures that + # running `np.test()` is deterministic and does not write any files. + # See https://hypothesis.readthedocs.io/en/latest/settings.html + hypothesis.settings.register_profile( + name="np.test() profile", + deadline=None, print_blob=True, database=None, derandomize=True, + suppress_health_check=hypothesis.HealthCheck.all(), + ) # run tests. _show_numpy_info() diff --git a/numpy/conftest.py b/numpy/conftest.py index 20c8a449e9b8..078b095661f1 100644 --- a/numpy/conftest.py +++ b/numpy/conftest.py @@ -2,6 +2,7 @@ Pytest configuration and fixtures for the Numpy test suite. """ import os +import tempfile import hypothesis import pytest @@ -13,11 +14,23 @@ _old_fpu_mode = None _collect_results = {} +# Use a known and persistent tmpdir for hypothesis' caches, which +# can be automatically cleared by the OS or user. +hypothesis.configuration.set_hypothesis_home_dir( + os.path.join(tempfile.gettempdir(), ".hypothesis") +) # See https://hypothesis.readthedocs.io/en/latest/settings.html hypothesis.settings.register_profile( name="numpy-profile", deadline=None, print_blob=True, ) -hypothesis.settings.load_profile("numpy-profile") +# We try loading the profile defined by np.test(), which disables the +# database and forces determinism, and fall back to the profile defined +# above if we're running pytest directly. The odd dance is required +# because np.test() executes this file *after* its own setup code. +try: + hypothesis.settings.load_profile("np.test() profile") +except hypothesis.errors.InvalidArgument: # profile not found + hypothesis.settings.load_profile("numpy-profile") def pytest_configure(config): From 7a204e8399fc09a4d8ffc04ab556da3801668fc6 Mon Sep 17 00:00:00 2001 From: mattip Date: Mon, 3 Aug 2020 13:20:55 +0300 Subject: [PATCH 04/13] BLD: pin setuptools<49.2.0 --- .circleci/config.yml | 2 +- azure-pipelines.yml | 4 ++-- pyproject.toml | 2 +- test_requirements.txt | 4 ++-- tools/travis-before-install.sh | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index c3d4352e82a0..2a986cba6a97 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -29,7 +29,7 @@ jobs: name: build numpy command: | . venv/bin/activate - pip install --upgrade pip setuptools + pip install --upgrade pip 'setuptools<49.2.0' pip install cython pip install . pip install scipy diff --git a/azure-pipelines.yml b/azure-pipelines.yml index f4d8ca142073..80b5b9770e57 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -129,7 +129,7 @@ stages: otool -L /usr/local/lib/libopenblas* displayName: 'install pre-built openblas' condition: eq(variables['USE_OPENBLAS'], '1') - - script: python -m pip install --upgrade pip setuptools wheel + - script: python -m pip install --upgrade pip 'setuptools<49.2.0' wheel displayName: 'Install tools' - script: | python -m pip install -r test_requirements.txt @@ -250,7 +250,7 @@ stages: displayName: 'add gcc 4.8' - script: | # python3 has no setuptools, so install one to get us going - python3 -m pip install --user --upgrade pip setuptools!=49.2.0 + python3 -m pip install --user --upgrade pip 'setuptools<49.2.0' python3 -m pip install --user -r test_requirements.txt CPPFLAGS='' CC=gcc-4.8 F77=gfortran-5 F90=gfortran-5 \ python3 runtests.py --debug-info --mode=full -- -rsx --junitxml=junit/test-results.xml diff --git a/pyproject.toml b/pyproject.toml index a54d0b379807..3566cc683d57 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [build-system] # Minimum requirements for the build system to execute. requires = [ - "setuptools!=49.2.0", + "setuptools<49.2.0", "wheel", "Cython>=0.29.21", # Note: keep in sync with tools/cythonize.py ] diff --git a/test_requirements.txt b/test_requirements.txt index 05e09cb7887d..171206435c17 100644 --- a/test_requirements.txt +++ b/test_requirements.txt @@ -1,7 +1,7 @@ cython==0.29.21 wheel -setuptools!=49.2.0 -hypothesis==5.19.1 +setuptools<49.2.0 +hypothesis==5.23.2 pytest==5.4.3 pytz==2020.1 pytest-cov==2.8.1 diff --git a/tools/travis-before-install.sh b/tools/travis-before-install.sh index 1446a8bad373..b62d74f40307 100755 --- a/tools/travis-before-install.sh +++ b/tools/travis-before-install.sh @@ -29,7 +29,7 @@ gcc --version popd -pip install --upgrade pip setuptools!=49.2.0 wheel +pip install --upgrade pip 'setuptools<49.2.0' wheel # 'setuptools', 'wheel' and 'cython' are build dependencies. This information # is stored in pyproject.toml, but there is not yet a standard way to install From f4c6fb1e13497121f42f3a8c3f01ccb792ef351b Mon Sep 17 00:00:00 2001 From: scoder Date: Wed, 5 Aug 2020 06:28:30 +0200 Subject: [PATCH 05/13] ENH: Add NumPy declarations to be used by Cython 3.0+ (#16986) * Create copy of numpy.pxd for Cython 3.0 changes and improve it. --- MANIFEST.in | 2 +- .../upcoming_changes/16986.improvement.rst | 7 + numpy/__init__.cython-30.pxd | 1032 +++++++++++++++++ numpy/__init__.pxd | 83 +- setup.py | 2 +- 5 files changed, 1045 insertions(+), 81 deletions(-) create mode 100644 doc/release/upcoming_changes/16986.improvement.rst create mode 100644 numpy/__init__.cython-30.pxd diff --git a/MANIFEST.in b/MANIFEST.in index b58f85d4d295..9392b811684f 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -16,7 +16,7 @@ include .coveragerc include test_requirements.txt recursive-include numpy/random *.pyx *.pxd *.pyx.in *.pxd.in include numpy/random/include/* -include numpy/__init__.pxd +include numpy/*.pxd # Add build support that should go in sdist, but not go in bdist/be installed # Note that sub-directories that don't have __init__ are apparently not # included by 'recursive-include', so list those separately diff --git a/doc/release/upcoming_changes/16986.improvement.rst b/doc/release/upcoming_changes/16986.improvement.rst new file mode 100644 index 000000000000..391322d9db99 --- /dev/null +++ b/doc/release/upcoming_changes/16986.improvement.rst @@ -0,0 +1,7 @@ +Add NumPy declarations for Cython 3.0 and later +----------------------------------------------- + +The pxd declarations for Cython 3.0 were improved to avoid using deprecated +NumPy C-API features. Extension modules built with Cython 3.0+ that use NumPy +can now set the C macro ``NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION`` to avoid +C compiler warnings about deprecated API usage. diff --git a/numpy/__init__.cython-30.pxd b/numpy/__init__.cython-30.pxd new file mode 100644 index 000000000000..55097888c744 --- /dev/null +++ b/numpy/__init__.cython-30.pxd @@ -0,0 +1,1032 @@ +# NumPy static imports for Cython >= 3.0 +# +# If any of the PyArray_* functions are called, import_array must be +# called first. This is done automatically by Cython 3.0+ if a call +# is not detected inside of the module. +# +# Author: Dag Sverre Seljebotn +# + +from cpython.ref cimport Py_INCREF +from cpython.object cimport PyObject, PyTypeObject, PyObject_TypeCheck +cimport libc.stdio as stdio + + +cdef extern from *: + # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython. + # See https://github.com/cython/cython/issues/3573 + """ + /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ + """ + + +cdef extern from "Python.h": + ctypedef Py_ssize_t Py_intptr_t + +cdef extern from "numpy/arrayobject.h": + ctypedef Py_intptr_t npy_intp + ctypedef size_t npy_uintp + + cdef enum NPY_TYPES: + NPY_BOOL + NPY_BYTE + NPY_UBYTE + NPY_SHORT + NPY_USHORT + NPY_INT + NPY_UINT + NPY_LONG + NPY_ULONG + NPY_LONGLONG + NPY_ULONGLONG + NPY_FLOAT + NPY_DOUBLE + NPY_LONGDOUBLE + NPY_CFLOAT + NPY_CDOUBLE + NPY_CLONGDOUBLE + NPY_OBJECT + NPY_STRING + NPY_UNICODE + NPY_VOID + NPY_DATETIME + NPY_TIMEDELTA + NPY_NTYPES + NPY_NOTYPE + + NPY_INT8 + NPY_INT16 + NPY_INT32 + NPY_INT64 + NPY_INT128 + NPY_INT256 + NPY_UINT8 + NPY_UINT16 + NPY_UINT32 + NPY_UINT64 + NPY_UINT128 + NPY_UINT256 + NPY_FLOAT16 + NPY_FLOAT32 + NPY_FLOAT64 + NPY_FLOAT80 + NPY_FLOAT96 + NPY_FLOAT128 + NPY_FLOAT256 + NPY_COMPLEX32 + NPY_COMPLEX64 + NPY_COMPLEX128 + NPY_COMPLEX160 + NPY_COMPLEX192 + NPY_COMPLEX256 + NPY_COMPLEX512 + + NPY_INTP + + ctypedef enum NPY_ORDER: + NPY_ANYORDER + NPY_CORDER + NPY_FORTRANORDER + NPY_KEEPORDER + + ctypedef enum NPY_CASTING: + NPY_NO_CASTING + NPY_EQUIV_CASTING + NPY_SAFE_CASTING + NPY_SAME_KIND_CASTING + NPY_UNSAFE_CASTING + + ctypedef enum NPY_CLIPMODE: + NPY_CLIP + NPY_WRAP + NPY_RAISE + + ctypedef enum NPY_SCALARKIND: + NPY_NOSCALAR, + NPY_BOOL_SCALAR, + NPY_INTPOS_SCALAR, + NPY_INTNEG_SCALAR, + NPY_FLOAT_SCALAR, + NPY_COMPLEX_SCALAR, + NPY_OBJECT_SCALAR + + ctypedef enum NPY_SORTKIND: + NPY_QUICKSORT + NPY_HEAPSORT + NPY_MERGESORT + + ctypedef enum NPY_SEARCHSIDE: + NPY_SEARCHLEFT + NPY_SEARCHRIGHT + + enum: + # DEPRECATED since NumPy 1.7 ! Do not use in new code! + NPY_C_CONTIGUOUS + NPY_F_CONTIGUOUS + NPY_CONTIGUOUS + NPY_FORTRAN + NPY_OWNDATA + NPY_FORCECAST + NPY_ENSURECOPY + NPY_ENSUREARRAY + NPY_ELEMENTSTRIDES + NPY_ALIGNED + NPY_NOTSWAPPED + NPY_WRITEABLE + NPY_UPDATEIFCOPY + NPY_ARR_HAS_DESCR + + NPY_BEHAVED + NPY_BEHAVED_NS + NPY_CARRAY + NPY_CARRAY_RO + NPY_FARRAY + NPY_FARRAY_RO + NPY_DEFAULT + + NPY_IN_ARRAY + NPY_OUT_ARRAY + NPY_INOUT_ARRAY + NPY_IN_FARRAY + NPY_OUT_FARRAY + NPY_INOUT_FARRAY + + NPY_UPDATE_ALL + + enum: + # Added in NumPy 1.7 to replace the deprecated enums above. + NPY_ARRAY_C_CONTIGUOUS + NPY_ARRAY_F_CONTIGUOUS + NPY_ARRAY_OWNDATA + NPY_ARRAY_FORCECAST + NPY_ARRAY_ENSURECOPY + NPY_ARRAY_ENSUREARRAY + NPY_ARRAY_ELEMENTSTRIDES + NPY_ARRAY_ALIGNED + NPY_ARRAY_NOTSWAPPED + NPY_ARRAY_WRITEABLE + NPY_ARRAY_UPDATEIFCOPY + + NPY_ARRAY_BEHAVED + NPY_ARRAY_BEHAVED_NS + NPY_ARRAY_CARRAY + NPY_ARRAY_CARRAY_RO + NPY_ARRAY_FARRAY + NPY_ARRAY_FARRAY_RO + NPY_ARRAY_DEFAULT + + NPY_ARRAY_IN_ARRAY + NPY_ARRAY_OUT_ARRAY + NPY_ARRAY_INOUT_ARRAY + NPY_ARRAY_IN_FARRAY + NPY_ARRAY_OUT_FARRAY + NPY_ARRAY_INOUT_FARRAY + + NPY_ARRAY_UPDATE_ALL + + cdef enum: + NPY_MAXDIMS + + npy_intp NPY_MAX_ELSIZE + + ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, void *) + + ctypedef struct PyArray_ArrayDescr: + # shape is a tuple, but Cython doesn't support "tuple shape" + # inside a non-PyObject declaration, so we have to declare it + # as just a PyObject*. + PyObject* shape + + ctypedef struct PyArray_Descr: + pass + + ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: + # Use PyDataType_* macros when possible, however there are no macros + # for accessing some of the fields, so some are defined. + cdef PyTypeObject* typeobj + cdef char kind + cdef char type + # Numpy sometimes mutates this without warning (e.g. it'll + # sometimes change "|" to "<" in shared dtype objects on + # little-endian machines). If this matters to you, use + # PyArray_IsNativeByteOrder(dtype.byteorder) instead of + # directly accessing this field. + cdef char byteorder + cdef char flags + cdef int type_num + cdef int itemsize "elsize" + cdef int alignment + cdef object fields + cdef tuple names + # Use PyDataType_HASSUBARRAY to test whether this field is + # valid (the pointer can be NULL). Most users should access + # this field via the inline helper method PyDataType_SHAPE. + cdef PyArray_ArrayDescr* subarray + + ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: + # Use through macros + pass + + ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + # Use through macros + pass + + ctypedef struct PyArrayObject: + # For use in situations where ndarray can't replace PyArrayObject*, + # like PyArrayObject**. + pass + + ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: + cdef __cythonbufferdefaults__ = {"mode": "strided"} + + # NOTE: no field declarations since direct access is deprecated since NumPy 1.7 + # Instead, we use properties that map to the corresponding C-API functions. + + @property + cdef inline PyObject* base(self) nogil: + """Returns a borrowed reference to the object owning the data/memory. + """ + return PyArray_BASE(self) + + @property + cdef inline dtype descr(self): + """Returns an owned reference to the dtype of the array. + """ + return PyArray_DESCR(self) + + @property + cdef inline int ndim(self) nogil: + """Returns the number of dimensions in the array. + """ + return PyArray_NDIM(self) + + @property + cdef inline npy_intp *shape(self) nogil: + """Returns a pointer to the dimensions/shape of the array. + The number of elements matches the number of dimensions of the array (ndim). + Can return NULL for 0-dimensional arrays. + """ + return PyArray_DIMS(self) + + @property + cdef inline npy_intp *strides(self) nogil: + """Returns a pointer to the strides of the array. + The number of elements matches the number of dimensions of the array (ndim). + """ + return PyArray_STRIDES(self) + + @property + cdef inline npy_intp size(self) nogil: + """Returns the total size (in number of elements) of the array. + """ + return PyArray_SIZE(self) + + @property + cdef inline char* data(self) nogil: + """The pointer to the data buffer as a char*. + This is provided for legacy reasons to avoid direct struct field access. + For new code that needs this access, you probably want to cast the result + of `PyArray_DATA()` instead, which returns a 'void*'. + """ + return PyArray_BYTES(self) + + ctypedef unsigned char npy_bool + + ctypedef signed char npy_byte + ctypedef signed short npy_short + ctypedef signed int npy_int + ctypedef signed long npy_long + ctypedef signed long long npy_longlong + + ctypedef unsigned char npy_ubyte + ctypedef unsigned short npy_ushort + ctypedef unsigned int npy_uint + ctypedef unsigned long npy_ulong + ctypedef unsigned long long npy_ulonglong + + ctypedef float npy_float + ctypedef double npy_double + ctypedef long double npy_longdouble + + ctypedef signed char npy_int8 + ctypedef signed short npy_int16 + ctypedef signed int npy_int32 + ctypedef signed long long npy_int64 + ctypedef signed long long npy_int96 + ctypedef signed long long npy_int128 + + ctypedef unsigned char npy_uint8 + ctypedef unsigned short npy_uint16 + ctypedef unsigned int npy_uint32 + ctypedef unsigned long long npy_uint64 + ctypedef unsigned long long npy_uint96 + ctypedef unsigned long long npy_uint128 + + ctypedef float npy_float32 + ctypedef double npy_float64 + ctypedef long double npy_float80 + ctypedef long double npy_float96 + ctypedef long double npy_float128 + + ctypedef struct npy_cfloat: + double real + double imag + + ctypedef struct npy_cdouble: + double real + double imag + + ctypedef struct npy_clongdouble: + long double real + long double imag + + ctypedef struct npy_complex64: + float real + float imag + + ctypedef struct npy_complex128: + double real + double imag + + ctypedef struct npy_complex160: + long double real + long double imag + + ctypedef struct npy_complex192: + long double real + long double imag + + ctypedef struct npy_complex256: + long double real + long double imag + + ctypedef struct PyArray_Dims: + npy_intp *ptr + int len + + int _import_array() except -1 + # A second definition so _import_array isn't marked as used when we use it here. + # Do not use - subject to change any time. + int __pyx_import_array "_import_array"() except -1 + + # + # Macros from ndarrayobject.h + # + bint PyArray_CHKFLAGS(ndarray m, int flags) nogil + bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil + bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil + bint PyArray_ISCONTIGUOUS(ndarray m) nogil + bint PyArray_ISWRITEABLE(ndarray m) nogil + bint PyArray_ISALIGNED(ndarray m) nogil + + int PyArray_NDIM(ndarray) nogil + bint PyArray_ISONESEGMENT(ndarray) nogil + bint PyArray_ISFORTRAN(ndarray) nogil + int PyArray_FORTRANIF(ndarray) nogil + + void* PyArray_DATA(ndarray) nogil + char* PyArray_BYTES(ndarray) nogil + + npy_intp* PyArray_DIMS(ndarray) nogil + npy_intp* PyArray_STRIDES(ndarray) nogil + npy_intp PyArray_DIM(ndarray, size_t) nogil + npy_intp PyArray_STRIDE(ndarray, size_t) nogil + + PyObject *PyArray_BASE(ndarray) nogil # returns borrowed reference! + PyArray_Descr *PyArray_DESCR(ndarray) nogil # returns borrowed reference to dtype! + PyArray_Descr *PyArray_DTYPE(ndarray) nogil # returns borrowed reference to dtype! NP 1.7+ alias for descr. + int PyArray_FLAGS(ndarray) nogil + void PyArray_CLEARFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + void PyArray_ENABLEFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + npy_intp PyArray_ITEMSIZE(ndarray) nogil + int PyArray_TYPE(ndarray arr) nogil + + object PyArray_GETITEM(ndarray arr, void *itemptr) + int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) + + bint PyTypeNum_ISBOOL(int) nogil + bint PyTypeNum_ISUNSIGNED(int) nogil + bint PyTypeNum_ISSIGNED(int) nogil + bint PyTypeNum_ISINTEGER(int) nogil + bint PyTypeNum_ISFLOAT(int) nogil + bint PyTypeNum_ISNUMBER(int) nogil + bint PyTypeNum_ISSTRING(int) nogil + bint PyTypeNum_ISCOMPLEX(int) nogil + bint PyTypeNum_ISPYTHON(int) nogil + bint PyTypeNum_ISFLEXIBLE(int) nogil + bint PyTypeNum_ISUSERDEF(int) nogil + bint PyTypeNum_ISEXTENDED(int) nogil + bint PyTypeNum_ISOBJECT(int) nogil + + bint PyDataType_ISBOOL(dtype) nogil + bint PyDataType_ISUNSIGNED(dtype) nogil + bint PyDataType_ISSIGNED(dtype) nogil + bint PyDataType_ISINTEGER(dtype) nogil + bint PyDataType_ISFLOAT(dtype) nogil + bint PyDataType_ISNUMBER(dtype) nogil + bint PyDataType_ISSTRING(dtype) nogil + bint PyDataType_ISCOMPLEX(dtype) nogil + bint PyDataType_ISPYTHON(dtype) nogil + bint PyDataType_ISFLEXIBLE(dtype) nogil + bint PyDataType_ISUSERDEF(dtype) nogil + bint PyDataType_ISEXTENDED(dtype) nogil + bint PyDataType_ISOBJECT(dtype) nogil + bint PyDataType_HASFIELDS(dtype) nogil + bint PyDataType_HASSUBARRAY(dtype) nogil + + bint PyArray_ISBOOL(ndarray) nogil + bint PyArray_ISUNSIGNED(ndarray) nogil + bint PyArray_ISSIGNED(ndarray) nogil + bint PyArray_ISINTEGER(ndarray) nogil + bint PyArray_ISFLOAT(ndarray) nogil + bint PyArray_ISNUMBER(ndarray) nogil + bint PyArray_ISSTRING(ndarray) nogil + bint PyArray_ISCOMPLEX(ndarray) nogil + bint PyArray_ISPYTHON(ndarray) nogil + bint PyArray_ISFLEXIBLE(ndarray) nogil + bint PyArray_ISUSERDEF(ndarray) nogil + bint PyArray_ISEXTENDED(ndarray) nogil + bint PyArray_ISOBJECT(ndarray) nogil + bint PyArray_HASFIELDS(ndarray) nogil + + bint PyArray_ISVARIABLE(ndarray) nogil + + bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil + bint PyArray_ISNBO(char) nogil # works on ndarray.byteorder + bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder + bint PyArray_ISNOTSWAPPED(ndarray) nogil + bint PyArray_ISBYTESWAPPED(ndarray) nogil + + bint PyArray_FLAGSWAP(ndarray, int) nogil + + bint PyArray_ISCARRAY(ndarray) nogil + bint PyArray_ISCARRAY_RO(ndarray) nogil + bint PyArray_ISFARRAY(ndarray) nogil + bint PyArray_ISFARRAY_RO(ndarray) nogil + bint PyArray_ISBEHAVED(ndarray) nogil + bint PyArray_ISBEHAVED_RO(ndarray) nogil + + + bint PyDataType_ISNOTSWAPPED(dtype) nogil + bint PyDataType_ISBYTESWAPPED(dtype) nogil + + bint PyArray_DescrCheck(object) + + bint PyArray_Check(object) + bint PyArray_CheckExact(object) + + # Cannot be supported due to out arg: + # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) + # bint PyArray_HasArrayInterface(op, out) + + + bint PyArray_IsZeroDim(object) + # Cannot be supported due to ## ## in macro: + # bint PyArray_IsScalar(object, verbatim work) + bint PyArray_CheckScalar(object) + bint PyArray_IsPythonNumber(object) + bint PyArray_IsPythonScalar(object) + bint PyArray_IsAnyScalar(object) + bint PyArray_CheckAnyScalar(object) + + ndarray PyArray_GETCONTIGUOUS(ndarray) + bint PyArray_SAMESHAPE(ndarray, ndarray) nogil + npy_intp PyArray_SIZE(ndarray) nogil + npy_intp PyArray_NBYTES(ndarray) nogil + + object PyArray_FROM_O(object) + object PyArray_FROM_OF(object m, int flags) + object PyArray_FROM_OT(object m, int type) + object PyArray_FROM_OTF(object m, int type, int flags) + object PyArray_FROMANY(object m, int type, int min, int max, int flags) + object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran) + object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) + void PyArray_FILLWBYTE(object, int val) + npy_intp PyArray_REFCOUNT(object) + object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) + unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) + bint PyArray_EquivByteorders(int b1, int b2) nogil + object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) + object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) + #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) + object PyArray_ToScalar(void* data, ndarray arr) + + void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil + void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil + void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil + void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil + + void PyArray_XDECREF_ERR(ndarray) + # Cannot be supported due to out arg + # void PyArray_DESCR_REPLACE(descr) + + + object PyArray_Copy(ndarray) + object PyArray_FromObject(object op, int type, int min_depth, int max_depth) + object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) + object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) + + object PyArray_Cast(ndarray mp, int type_num) + object PyArray_Take(ndarray ap, object items, int axis) + object PyArray_Put(ndarray ap, object items, object values) + + void PyArray_ITER_RESET(flatiter it) nogil + void PyArray_ITER_NEXT(flatiter it) nogil + void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil + void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil + void* PyArray_ITER_DATA(flatiter it) nogil + bint PyArray_ITER_NOTDONE(flatiter it) nogil + + void PyArray_MultiIter_RESET(broadcast multi) nogil + void PyArray_MultiIter_NEXT(broadcast multi) nogil + void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil + void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil + void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil + void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil + bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil + + # Functions from __multiarray_api.h + + # Functions taking dtype and returning object/ndarray are disabled + # for now as they steal dtype references. I'm conservative and disable + # more than is probably needed until it can be checked further. + int PyArray_SetNumericOps (object) + object PyArray_GetNumericOps () + int PyArray_INCREF (ndarray) + int PyArray_XDECREF (ndarray) + void PyArray_SetStringFunction (object, int) + dtype PyArray_DescrFromType (int) + object PyArray_TypeObjectFromType (int) + char * PyArray_Zero (ndarray) + char * PyArray_One (ndarray) + #object PyArray_CastToType (ndarray, dtype, int) + int PyArray_CastTo (ndarray, ndarray) + int PyArray_CastAnyTo (ndarray, ndarray) + int PyArray_CanCastSafely (int, int) + npy_bool PyArray_CanCastTo (dtype, dtype) + int PyArray_ObjectType (object, int) + dtype PyArray_DescrFromObject (object, dtype) + #ndarray* PyArray_ConvertToCommonType (object, int *) + dtype PyArray_DescrFromScalar (object) + dtype PyArray_DescrFromTypeObject (object) + npy_intp PyArray_Size (object) + #object PyArray_Scalar (void *, dtype, object) + #object PyArray_FromScalar (object, dtype) + void PyArray_ScalarAsCtype (object, void *) + #int PyArray_CastScalarToCtype (object, void *, dtype) + #int PyArray_CastScalarDirect (object, dtype, void *, int) + object PyArray_ScalarFromObject (object) + #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int) + object PyArray_FromDims (int, int *, int) + #object PyArray_FromDimsAndDataAndDescr (int, int *, dtype, char *) + #object PyArray_FromAny (object, dtype, int, int, int, object) + object PyArray_EnsureArray (object) + object PyArray_EnsureAnyArray (object) + #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *) + #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *) + #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) + #object PyArray_FromIter (object, dtype, npy_intp) + object PyArray_Return (ndarray) + #object PyArray_GetField (ndarray, dtype, int) + #int PyArray_SetField (ndarray, dtype, int, object) + object PyArray_Byteswap (ndarray, npy_bool) + object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER) + int PyArray_MoveInto (ndarray, ndarray) + int PyArray_CopyInto (ndarray, ndarray) + int PyArray_CopyAnyInto (ndarray, ndarray) + int PyArray_CopyObject (ndarray, object) + object PyArray_NewCopy (ndarray, NPY_ORDER) + object PyArray_ToList (ndarray) + object PyArray_ToString (ndarray, NPY_ORDER) + int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) + int PyArray_Dump (object, object, int) + object PyArray_Dumps (object, int) + int PyArray_ValidType (int) + void PyArray_UpdateFlags (ndarray, int) + object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object) + #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object) + #dtype PyArray_DescrNew (dtype) + dtype PyArray_DescrNewFromType (int) + double PyArray_GetPriority (object, double) + object PyArray_IterNew (object) + object PyArray_MultiIterNew (int, ...) + + int PyArray_PyIntAsInt (object) + npy_intp PyArray_PyIntAsIntp (object) + int PyArray_Broadcast (broadcast) + void PyArray_FillObjectArray (ndarray, object) + int PyArray_FillWithScalar (ndarray, object) + npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *) + dtype PyArray_DescrNewByteorder (dtype, char) + object PyArray_IterAllButAxis (object, int *) + #object PyArray_CheckFromAny (object, dtype, int, int, int, object) + #object PyArray_FromArray (ndarray, dtype, int) + object PyArray_FromInterface (object) + object PyArray_FromStructInterface (object) + #object PyArray_FromArrayAttr (object, dtype, object) + #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*) + int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) + object PyArray_NewFlagsObject (object) + npy_bool PyArray_CanCastScalar (type, type) + #int PyArray_CompareUCS4 (npy_ucs4 *, npy_ucs4 *, register size_t) + int PyArray_RemoveSmallest (broadcast) + int PyArray_ElementStrides (object) + void PyArray_Item_INCREF (char *, dtype) + void PyArray_Item_XDECREF (char *, dtype) + object PyArray_FieldNames (object) + object PyArray_Transpose (ndarray, PyArray_Dims *) + object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) + object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) + object PyArray_PutMask (ndarray, object, object) + object PyArray_Repeat (ndarray, object, int) + object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) + int PyArray_Sort (ndarray, int, NPY_SORTKIND) + object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) + object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *) + object PyArray_ArgMax (ndarray, int, ndarray) + object PyArray_ArgMin (ndarray, int, ndarray) + object PyArray_Reshape (ndarray, object) + object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER) + object PyArray_Squeeze (ndarray) + #object PyArray_View (ndarray, dtype, type) + object PyArray_SwapAxes (ndarray, int, int) + object PyArray_Max (ndarray, int, ndarray) + object PyArray_Min (ndarray, int, ndarray) + object PyArray_Ptp (ndarray, int, ndarray) + object PyArray_Mean (ndarray, int, int, ndarray) + object PyArray_Trace (ndarray, int, int, int, int, ndarray) + object PyArray_Diagonal (ndarray, int, int, int) + object PyArray_Clip (ndarray, object, object, ndarray) + object PyArray_Conjugate (ndarray, ndarray) + object PyArray_Nonzero (ndarray) + object PyArray_Std (ndarray, int, int, ndarray, int) + object PyArray_Sum (ndarray, int, int, ndarray) + object PyArray_CumSum (ndarray, int, int, ndarray) + object PyArray_Prod (ndarray, int, int, ndarray) + object PyArray_CumProd (ndarray, int, int, ndarray) + object PyArray_All (ndarray, int, ndarray) + object PyArray_Any (ndarray, int, ndarray) + object PyArray_Compress (ndarray, object, int, ndarray) + object PyArray_Flatten (ndarray, NPY_ORDER) + object PyArray_Ravel (ndarray, NPY_ORDER) + npy_intp PyArray_MultiplyList (npy_intp *, int) + int PyArray_MultiplyIntList (int *, int) + void * PyArray_GetPtr (ndarray, npy_intp*) + int PyArray_CompareLists (npy_intp *, npy_intp *, int) + #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype) + #int PyArray_As1D (object*, char **, int *, int) + #int PyArray_As2D (object*, char ***, int *, int *, int) + int PyArray_Free (object, void *) + #int PyArray_Converter (object, object*) + int PyArray_IntpFromSequence (object, npy_intp *, int) + object PyArray_Concatenate (object, int) + object PyArray_InnerProduct (object, object) + object PyArray_MatrixProduct (object, object) + object PyArray_CopyAndTranspose (object) + object PyArray_Correlate (object, object, int) + int PyArray_TypestrConvert (int, int) + #int PyArray_DescrConverter (object, dtype*) + #int PyArray_DescrConverter2 (object, dtype*) + int PyArray_IntpConverter (object, PyArray_Dims *) + #int PyArray_BufferConverter (object, chunk) + int PyArray_AxisConverter (object, int *) + int PyArray_BoolConverter (object, npy_bool *) + int PyArray_ByteorderConverter (object, char *) + int PyArray_OrderConverter (object, NPY_ORDER *) + unsigned char PyArray_EquivTypes (dtype, dtype) + #object PyArray_Zeros (int, npy_intp *, dtype, int) + #object PyArray_Empty (int, npy_intp *, dtype, int) + object PyArray_Where (object, object, object) + object PyArray_Arange (double, double, double, int) + #object PyArray_ArangeObj (object, object, object, dtype) + int PyArray_SortkindConverter (object, NPY_SORTKIND *) + object PyArray_LexSort (object, int) + object PyArray_Round (ndarray, int, ndarray) + unsigned char PyArray_EquivTypenums (int, int) + int PyArray_RegisterDataType (dtype) + int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) + int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) + #void PyArray_InitArrFuncs (PyArray_ArrFuncs *) + object PyArray_IntTupleFromIntp (int, npy_intp *) + int PyArray_TypeNumFromName (char *) + int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) + #int PyArray_OutputConverter (object, ndarray*) + object PyArray_BroadcastToShape (object, npy_intp *, int) + void _PyArray_SigintHandler (int) + void* _PyArray_GetSigintBuf () + #int PyArray_DescrAlignConverter (object, dtype*) + #int PyArray_DescrAlignConverter2 (object, dtype*) + int PyArray_SearchsideConverter (object, void *) + object PyArray_CheckAxis (ndarray, int *, int) + npy_intp PyArray_OverflowMultiplyList (npy_intp *, int) + int PyArray_CompareString (char *, char *, size_t) + int PyArray_SetBaseObject(ndarray, base) # NOTE: steals a reference to base! Use "set_array_base()" instead. + + +# Typedefs that matches the runtime dtype objects in +# the numpy module. + +# The ones that are commented out needs an IFDEF function +# in Cython to enable them only on the right systems. + +ctypedef npy_int8 int8_t +ctypedef npy_int16 int16_t +ctypedef npy_int32 int32_t +ctypedef npy_int64 int64_t +#ctypedef npy_int96 int96_t +#ctypedef npy_int128 int128_t + +ctypedef npy_uint8 uint8_t +ctypedef npy_uint16 uint16_t +ctypedef npy_uint32 uint32_t +ctypedef npy_uint64 uint64_t +#ctypedef npy_uint96 uint96_t +#ctypedef npy_uint128 uint128_t + +ctypedef npy_float32 float32_t +ctypedef npy_float64 float64_t +#ctypedef npy_float80 float80_t +#ctypedef npy_float128 float128_t + +ctypedef float complex complex64_t +ctypedef double complex complex128_t + +# The int types are mapped a bit surprising -- +# numpy.int corresponds to 'l' and numpy.long to 'q' +ctypedef npy_long int_t +ctypedef npy_longlong long_t +ctypedef npy_longlong longlong_t + +ctypedef npy_ulong uint_t +ctypedef npy_ulonglong ulong_t +ctypedef npy_ulonglong ulonglong_t + +ctypedef npy_intp intp_t +ctypedef npy_uintp uintp_t + +ctypedef npy_double float_t +ctypedef npy_double double_t +ctypedef npy_longdouble longdouble_t + +ctypedef npy_cfloat cfloat_t +ctypedef npy_cdouble cdouble_t +ctypedef npy_clongdouble clongdouble_t + +ctypedef npy_cdouble complex_t + +cdef inline object PyArray_MultiIterNew1(a): + return PyArray_MultiIterNew(1, a) + +cdef inline object PyArray_MultiIterNew2(a, b): + return PyArray_MultiIterNew(2, a, b) + +cdef inline object PyArray_MultiIterNew3(a, b, c): + return PyArray_MultiIterNew(3, a, b, c) + +cdef inline object PyArray_MultiIterNew4(a, b, c, d): + return PyArray_MultiIterNew(4, a, b, c, d) + +cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + return PyArray_MultiIterNew(5, a, b, c, d, e) + +cdef inline tuple PyDataType_SHAPE(dtype d): + if PyDataType_HASSUBARRAY(d): + return d.subarray.shape + else: + return () + + +cdef extern from "numpy/ndarrayobject.h": + PyTypeObject PyTimedeltaArrType_Type + PyTypeObject PyDatetimeArrType_Type + ctypedef int64_t npy_timedelta + ctypedef int64_t npy_datetime + +cdef extern from "numpy/ndarraytypes.h": + ctypedef struct PyArray_DatetimeMetaData: + NPY_DATETIMEUNIT base + int64_t num + +cdef extern from "numpy/arrayscalars.h": + ctypedef struct PyDatetimeScalarObject: + # PyObject_HEAD + npy_datetime obval + PyArray_DatetimeMetaData obmeta + + ctypedef struct PyTimedeltaScalarObject: + # PyObject_HEAD + npy_timedelta obval + PyArray_DatetimeMetaData obmeta + + ctypedef enum NPY_DATETIMEUNIT: + NPY_FR_Y + NPY_FR_M + NPY_FR_W + NPY_FR_D + NPY_FR_B + NPY_FR_h + NPY_FR_m + NPY_FR_s + NPY_FR_ms + NPY_FR_us + NPY_FR_ns + NPY_FR_ps + NPY_FR_fs + NPY_FR_as + + +# +# ufunc API +# + +cdef extern from "numpy/ufuncobject.h": + + ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *) + + ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: + cdef: + int nin, nout, nargs + int identity + PyUFuncGenericFunction *functions + void **data + int ntypes + int check_return + char *name + char *types + char *doc + void *ptr + PyObject *obj + PyObject *userloops + + cdef enum: + PyUFunc_Zero + PyUFunc_One + PyUFunc_None + UFUNC_ERR_IGNORE + UFUNC_ERR_WARN + UFUNC_ERR_RAISE + UFUNC_ERR_CALL + UFUNC_ERR_PRINT + UFUNC_ERR_LOG + UFUNC_MASK_DIVIDEBYZERO + UFUNC_MASK_OVERFLOW + UFUNC_MASK_UNDERFLOW + UFUNC_MASK_INVALID + UFUNC_SHIFT_DIVIDEBYZERO + UFUNC_SHIFT_OVERFLOW + UFUNC_SHIFT_UNDERFLOW + UFUNC_SHIFT_INVALID + UFUNC_FPE_DIVIDEBYZERO + UFUNC_FPE_OVERFLOW + UFUNC_FPE_UNDERFLOW + UFUNC_FPE_INVALID + UFUNC_ERR_DEFAULT + UFUNC_ERR_DEFAULT2 + + object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *, + void **, char *, int, int, int, int, char *, char *, int) + int PyUFunc_RegisterLoopForType(ufunc, int, + PyUFuncGenericFunction, int *, void *) + int PyUFunc_GenericFunction \ + (ufunc, PyObject *, PyObject *, PyArrayObject **) + void PyUFunc_f_f_As_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_f_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_g_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F_As_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_G_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f_As_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_gg_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F_As_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_GG_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_On_Om \ + (char **, npy_intp *, npy_intp *, void *) + int PyUFunc_GetPyValues \ + (char *, int *, int *, PyObject **) + int PyUFunc_checkfperr \ + (int, PyObject *, int *) + void PyUFunc_clearfperr() + int PyUFunc_getfperr() + int PyUFunc_handlefperr \ + (int, PyObject *, int, int *) + int PyUFunc_ReplaceLoopBySignature \ + (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *) + object PyUFunc_FromFuncAndDataAndSignature \ + (PyUFuncGenericFunction *, void **, char *, int, int, int, + int, char *, char *, int, char *) + + int _import_umath() except -1 + +cdef inline void set_array_base(ndarray arr, object base): + Py_INCREF(base) # important to do this before stealing the reference below! + PyArray_SetBaseObject(arr, base) + +cdef inline object get_array_base(ndarray arr): + base = PyArray_BASE(arr) + if base is NULL: + return None + return base + +# Versions of the import_* functions which are more suitable for +# Cython code. +cdef inline int import_array() except -1: + try: + __pyx_import_array() + except Exception: + raise ImportError("numpy.core.multiarray failed to import") + +cdef inline int import_umath() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy.core.umath failed to import") + +cdef inline int import_ufunc() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy.core.umath failed to import") + + +cdef inline bint is_timedelta64_object(object obj): + """ + Cython equivalent of `isinstance(obj, np.timedelta64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) + + +cdef inline bint is_datetime64_object(object obj): + """ + Cython equivalent of `isinstance(obj, np.datetime64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) + + +cdef inline npy_datetime get_datetime64_value(object obj) nogil: + """ + returns the int64 value underlying scalar numpy datetime64 object + + Note that to interpret this as a datetime, the corresponding unit is + also needed. That can be found using `get_datetime64_unit`. + """ + return (obj).obval + + +cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: + """ + returns the int64 value underlying scalar numpy timedelta64 object + """ + return (obj).obval + + +cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: + """ + returns the unit part of the dtype for a numpy datetime64 object. + """ + return (obj).obmeta.base diff --git a/numpy/__init__.pxd b/numpy/__init__.pxd index fd736a9c16ba..1656fa8b2c81 100644 --- a/numpy/__init__.pxd +++ b/numpy/__init__.pxd @@ -1,16 +1,8 @@ -# NumPy static imports for Cython +# NumPy static imports for Cython < 3.0 # # If any of the PyArray_* functions are called, import_array must be # called first. # -# This also defines backwards-compatibility buffer acquisition -# code for use in Python 2.x (or Python <= 2.5 when NumPy starts -# implementing PEP-3118 directly). -# -# Because of laziness, the format string of the buffer is statically -# allocated. Increase the size if this is not enough, or submit a -# patch to do this properly. -# # Author: Dag Sverre Seljebotn # @@ -227,11 +219,11 @@ cdef extern from "numpy/arrayobject.h": # this field via the inline helper method PyDataType_SHAPE. cdef PyArray_ArrayDescr* subarray - ctypedef extern class numpy.flatiter [object PyArrayIterObject, check_size ignore]: + ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: # Use through macros pass - ctypedef extern class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: cdef int numiter cdef npy_intp size, index cdef int nd @@ -760,73 +752,6 @@ cdef inline tuple PyDataType_SHAPE(dtype d): else: return () -cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: - # Recursive utility function used in __getbuffer__ to get format - # string. The new location in the format string is returned. - - cdef dtype child - cdef int endian_detector = 1 - cdef bint little_endian = ((&endian_detector)[0] != 0) - cdef tuple fields - - for childname in descr.names: - fields = descr.fields[childname] - child, new_offset = fields - - if (end - f) - (new_offset - offset[0]) < 15: - raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - - if ((child.byteorder == c'>' and little_endian) or - (child.byteorder == c'<' and not little_endian)): - raise ValueError(u"Non-native byte order not supported") - # One could encode it in the format string and have Cython - # complain instead, BUT: < and > in format strings also imply - # standardized sizes for datatypes, and we rely on native in - # order to avoid reencoding data types based on their size. - # - # A proper PEP 3118 exporter for other clients than Cython - # must deal properly with this! - - # Output padding bytes - while offset[0] < new_offset: - f[0] = 120 # "x"; pad byte - f += 1 - offset[0] += 1 - - offset[0] += child.itemsize - - if not PyDataType_HASFIELDS(child): - t = child.type_num - if end - f < 5: - raise RuntimeError(u"Format string allocated too short.") - - # Until ticket #99 is fixed, use integers to avoid warnings - if t == NPY_BYTE: f[0] = 98 #"b" - elif t == NPY_UBYTE: f[0] = 66 #"B" - elif t == NPY_SHORT: f[0] = 104 #"h" - elif t == NPY_USHORT: f[0] = 72 #"H" - elif t == NPY_INT: f[0] = 105 #"i" - elif t == NPY_UINT: f[0] = 73 #"I" - elif t == NPY_LONG: f[0] = 108 #"l" - elif t == NPY_ULONG: f[0] = 76 #"L" - elif t == NPY_LONGLONG: f[0] = 113 #"q" - elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - elif t == NPY_FLOAT: f[0] = 102 #"f" - elif t == NPY_DOUBLE: f[0] = 100 #"d" - elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - elif t == NPY_OBJECT: f[0] = 79 #"O" - else: - raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - f += 1 - else: - # Cython ignores struct boundary information ("T{...}"), - # so don't output it - f = _util_dtypestring(child, f, end, offset) - return f - # # ufunc API @@ -836,7 +761,7 @@ cdef extern from "numpy/ufuncobject.h": ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *) - ctypedef extern class numpy.ufunc [object PyUFuncObject, check_size ignore]: + ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: cdef: int nin, nout, nargs int identity diff --git a/setup.py b/setup.py index ab391a4fe2ae..1fa2eb299b33 100755 --- a/setup.py +++ b/setup.py @@ -161,7 +161,7 @@ def configuration(parent_package='',top_path=None): config.add_subpackage('numpy') config.add_data_files(('numpy', 'LICENSE.txt')) - config.add_data_files(('numpy', 'numpy/__init__.pxd')) + config.add_data_files(('numpy', 'numpy/*.pxd')) config.get_version('numpy/version.py') # sets config.version From c52210793608b75943873cb8218afb0f1d54497f Mon Sep 17 00:00:00 2001 From: Sebastian Berg Date: Mon, 8 Jun 2020 08:56:54 -0500 Subject: [PATCH 06/13] BUG: Remove non-threadsafe sigint handling from fft calculation The fft calculation is the only point in our code where this function is used. Allowing Ctrl+C, in FFT specifically used have more reasons, since before pocketfft, some array-sizes could lead to very large run-times. Pocketfft fixed that issue, and now FFT is not really any slower, faster, or memory hungry than any other NumPy operation so it feels it does not need this handling. Rather, if we can find a better solution, it should also be added to more functions. The reason for removal is that it is not only unsafe while the FFT is running (in theory). Multiple, threaded FFT run can easily leave the signal handler in a bad state, causing crashes if Ctrl+C (sigint) is given at any point after the call. It would be possible to patch that over, by only resetting the signal handler if we actually changed it (or even more complex tricks), or possibly only using this technique when on the main thread. But, all of these solutions seem to complicate things, when the main reason for why allowing sigint seems useful is gone with pocketfft. --- numpy/core/include/numpy/npy_interrupt.h | 91 ++++---------------- numpy/core/multiarray.py | 2 +- numpy/core/src/multiarray/multiarraymodule.c | 33 ------- numpy/fft/_pocketfft.c | 6 -- 4 files changed, 16 insertions(+), 116 deletions(-) diff --git a/numpy/core/include/numpy/npy_interrupt.h b/numpy/core/include/numpy/npy_interrupt.h index 40cb7ac5efdb..bcb539326e88 100644 --- a/numpy/core/include/numpy/npy_interrupt.h +++ b/numpy/core/include/numpy/npy_interrupt.h @@ -1,79 +1,18 @@ - -/* Signal handling: - -This header file defines macros that allow your code to handle -interrupts received during processing. Interrupts that -could reasonably be handled: - -SIGINT, SIGABRT, SIGALRM, SIGSEGV - -****Warning*************** - -Do not allow code that creates temporary memory or increases reference -counts of Python objects to be interrupted unless you handle it -differently. - -************************** - -The mechanism for handling interrupts is conceptually simple: - - - replace the signal handler with our own home-grown version - and store the old one. - - run the code to be interrupted -- if an interrupt occurs - the handler should basically just cause a return to the - calling function for finish work. - - restore the old signal handler - -Of course, every code that allows interrupts must account for -returning via the interrupt and handle clean-up correctly. But, -even still, the simple paradigm is complicated by at least three -factors. - - 1) platform portability (i.e. Microsoft says not to use longjmp - to return from signal handling. They have a __try and __except - extension to C instead but what about mingw?). - - 2) how to handle threads: apparently whether signals are delivered to - every thread of the process or the "invoking" thread is platform - dependent. --- we don't handle threads for now. - - 3) do we need to worry about re-entrance. For now, assume the - code will not call-back into itself. - -Ideas: - - 1) Start by implementing an approach that works on platforms that - can use setjmp and longjmp functionality and does nothing - on other platforms. - - 2) Ignore threads --- i.e. do not mix interrupt handling and threads - - 3) Add a default signal_handler function to the C-API but have the rest - use macros. - - -Simple Interface: - - -In your C-extension: around a block of code you want to be interruptible -with a SIGINT - -NPY_SIGINT_ON -[code] -NPY_SIGINT_OFF - -In order for this to work correctly, the -[code] block must not allocate any memory or alter the reference count of any -Python objects. In other words [code] must be interruptible so that continuation -after NPY_SIGINT_OFF will only be "missing some computations" - -Interrupt handling does not work well with threads. - -*/ - -/* Add signal handling macros - Make the global variable and signal handler part of the C-API -*/ +/* + * This API is only provided because it is part of publicly exported + * headers. Its use is considered DEPRECATED, and it will be removed + * eventually. + * (This includes the _PyArray_SigintHandler and _PyArray_GetSigintBuf + * functions which are however, public API, and not headers.) + * + * Instead of using these non-threadsafe macros consider periodically + * querying `PyErr_CheckSignals()` or `PyOS_InterruptOccurred()` will work. + * Both of these require holding the GIL, although cpython could add a + * version of `PyOS_InterruptOccurred()` which does not. Such a version + * actually exists as private API in Python 3.10, and backported to 3.9 and 3.8, + * see also https://bugs.python.org/issue41037 and + * https://github.com/python/cpython/pull/20599). + */ #ifndef NPY_INTERRUPT_H #define NPY_INTERRUPT_H diff --git a/numpy/core/multiarray.py b/numpy/core/multiarray.py index 2cc2a8e710c1..b196687afc6b 100644 --- a/numpy/core/multiarray.py +++ b/numpy/core/multiarray.py @@ -38,7 +38,7 @@ 'nested_iters', 'normalize_axis_index', 'packbits', 'promote_types', 'putmask', 'ravel_multi_index', 'result_type', 'scalar', 'set_datetimeparse_function', 'set_legacy_print_mode', 'set_numeric_ops', - 'set_string_function', 'set_typeDict', 'shares_memory', 'test_interrupt', + 'set_string_function', 'set_typeDict', 'shares_memory', 'tracemalloc_domain', 'typeinfo', 'unpackbits', 'unravel_index', 'vdot', 'where', 'zeros'] diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c index a9f673d93a23..610618f7377e 100644 --- a/numpy/core/src/multiarray/multiarraymodule.c +++ b/numpy/core/src/multiarray/multiarraymodule.c @@ -3795,36 +3795,6 @@ _PyArray_GetSigintBuf(void) #endif -static PyObject * -test_interrupt(PyObject *NPY_UNUSED(self), PyObject *args) -{ - int kind = 0; - int a = 0; - - if (!PyArg_ParseTuple(args, "|i:test_interrupt", &kind)) { - return NULL; - } - if (kind) { - Py_BEGIN_ALLOW_THREADS; - while (a >= 0) { - if ((a % 1000 == 0) && PyOS_InterruptOccurred()) { - break; - } - a += 1; - } - Py_END_ALLOW_THREADS; - } - else { - NPY_SIGINT_ON - while(a >= 0) { - a += 1; - } - NPY_SIGINT_OFF - } - return PyInt_FromLong(a); -} - - static PyObject * array_shares_memory_impl(PyObject *args, PyObject *kwds, Py_ssize_t default_max_work, int raise_exceptions) @@ -4119,9 +4089,6 @@ static struct PyMethodDef array_module_methods[] = { {"_vec_string", (PyCFunction)_vec_string, METH_VARARGS | METH_KEYWORDS, NULL}, - {"test_interrupt", - (PyCFunction)test_interrupt, - METH_VARARGS, NULL}, {"_insert", (PyCFunction)arr_insert, METH_VARARGS | METH_KEYWORDS, "Insert vals sequentially into equivalent 1-d positions " diff --git a/numpy/fft/_pocketfft.c b/numpy/fft/_pocketfft.c index 764116a840ab..ba9995f97254 100644 --- a/numpy/fft/_pocketfft.c +++ b/numpy/fft/_pocketfft.c @@ -2206,7 +2206,6 @@ execute_complex(PyObject *a1, int is_forward, double fct) double *dptr = (double *)PyArray_DATA(data); int fail=0; Py_BEGIN_ALLOW_THREADS; - NPY_SIGINT_ON; plan = make_cfft_plan(npts); if (!plan) fail=1; if (!fail) @@ -2217,7 +2216,6 @@ execute_complex(PyObject *a1, int is_forward, double fct) dptr += npts*2; } if (plan) destroy_cfft_plan(plan); - NPY_SIGINT_OFF; Py_END_ALLOW_THREADS; if (fail) { Py_XDECREF(data); @@ -2258,7 +2256,6 @@ execute_real_forward(PyObject *a1, double fct) *dptr = (double *)PyArray_DATA(data); Py_BEGIN_ALLOW_THREADS; - NPY_SIGINT_ON; plan = make_rfft_plan(npts); if (!plan) fail=1; if (!fail) @@ -2272,7 +2269,6 @@ execute_real_forward(PyObject *a1, double fct) dptr += npts; } if (plan) destroy_rfft_plan(plan); - NPY_SIGINT_OFF; Py_END_ALLOW_THREADS; } if (fail) { @@ -2303,7 +2299,6 @@ execute_real_backward(PyObject *a1, double fct) *dptr = (double *)PyArray_DATA(data); Py_BEGIN_ALLOW_THREADS; - NPY_SIGINT_ON; plan = make_rfft_plan(npts); if (!plan) fail=1; if (!fail) { @@ -2316,7 +2311,6 @@ execute_real_backward(PyObject *a1, double fct) } } if (plan) destroy_rfft_plan(plan); - NPY_SIGINT_OFF; Py_END_ALLOW_THREADS; } if (fail) { From 8251783696a9d8fe80b81afdb40c280c54108b75 Mon Sep 17 00:00:00 2001 From: Pauli Virtanen Date: Thu, 20 Aug 2020 20:56:18 +0300 Subject: [PATCH 07/13] BUG: core: fix ilp64 blas dot/vdot/... for strides > int32 max Fix overlooked int cast when HAVE_BLAS_ILP64 is defined. It was supposed to cast to CBLAS_INT, not int. Also add a regression test. Move blas_stride() to npy_cblas.h Replace npy_is_aligned by modulo; we're going to call BLAS so no need to micro-optimize integer division here. --- numpy/core/src/common/npy_cblas.h | 26 ++++++++++++++++++++++++++ numpy/core/src/multiarray/common.h | 24 ------------------------ numpy/core/tests/test_regression.py | 15 ++++++++++++++- 3 files changed, 40 insertions(+), 25 deletions(-) diff --git a/numpy/core/src/common/npy_cblas.h b/numpy/core/src/common/npy_cblas.h index 97308238a23d..c0441e81e781 100644 --- a/numpy/core/src/common/npy_cblas.h +++ b/numpy/core/src/common/npy_cblas.h @@ -59,6 +59,32 @@ enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; #undef BLASINT #undef BLASNAME + +/* + * Convert NumPy stride to BLAS stride. Returns 0 if conversion cannot be done + * (BLAS won't handle negative or zero strides the way we want). + */ +static NPY_INLINE CBLAS_INT +blas_stride(npy_intp stride, unsigned itemsize) +{ + /* + * Should probably check pointer alignment also, but this may cause + * problems if we require complex to be 16 byte aligned. + */ + if (stride > 0 && (stride % itemsize) == 0) { + stride /= itemsize; +#ifndef HAVE_BLAS_ILP64 + if (stride <= INT_MAX) { +#else + if (stride <= NPY_MAX_INT64) { +#endif + return stride; + } + } + return 0; +} + + #ifdef __cplusplus } #endif diff --git a/numpy/core/src/multiarray/common.h b/numpy/core/src/multiarray/common.h index 4913eb202f22..48ca320dd45f 100644 --- a/numpy/core/src/multiarray/common.h +++ b/numpy/core/src/multiarray/common.h @@ -290,30 +290,6 @@ npy_memchr(char * haystack, char needle, return p; } -/* - * Convert NumPy stride to BLAS stride. Returns 0 if conversion cannot be done - * (BLAS won't handle negative or zero strides the way we want). - */ -static NPY_INLINE int -blas_stride(npy_intp stride, unsigned itemsize) -{ - /* - * Should probably check pointer alignment also, but this may cause - * problems if we require complex to be 16 byte aligned. - */ - if (stride > 0 && npy_is_aligned((void *)stride, itemsize)) { - stride /= itemsize; -#ifndef HAVE_BLAS_ILP64 - if (stride <= INT_MAX) { -#else - if (stride <= NPY_MAX_INT64) { -#endif - return stride; - } - } - return 0; -} - /* * Define a chunksize for CBLAS. CBLAS counts in integers. */ diff --git a/numpy/core/tests/test_regression.py b/numpy/core/tests/test_regression.py index ef205555a407..9b487f37dc6c 100644 --- a/numpy/core/tests/test_regression.py +++ b/numpy/core/tests/test_regression.py @@ -14,7 +14,7 @@ assert_raises_regex, assert_warns, suppress_warnings, _assert_valid_refcount, HAS_REFCOUNT, ) -from numpy.testing._private.utils import _no_tracing +from numpy.testing._private.utils import _no_tracing, requires_memory from numpy.compat import asbytes, asunicode, pickle try: @@ -2490,3 +2490,16 @@ def test_to_ctypes(self): assert arr.size * arr.itemsize > 2 ** 31 c_arr = np.ctypeslib.as_ctypes(arr) assert_equal(c_arr._length_, arr.size) + + @pytest.mark.skipif(sys.maxsize < 2 ** 31 + 1, reason='overflows 32-bit python') + @requires_memory(free_bytes=9e9) + def test_dot_big_stride(self): + # gh-17111 + # blas stride = stride//itemsize > int32 max + int32_max = np.iinfo(np.int32).max + n = int32_max + 3 + a = np.empty([n], dtype=np.float32) + b = a[::n-1] + b[...] = 1 + assert b.strides[0] > int32_max * b.dtype.itemsize + assert np.dot(b, b) == 2.0 From b0946ae736051a3a8533526760c23b4b43477afe Mon Sep 17 00:00:00 2001 From: Pauli Virtanen Date: Fri, 21 Aug 2020 23:11:43 +0300 Subject: [PATCH 08/13] MAINT: npy_cblas.h: redefine NPY_CBLAS_CHUNK in terms of CBLAS_INT_MAX --- numpy/core/src/common/npy_cblas.h | 19 ++++++++++++++----- numpy/core/src/multiarray/common.h | 13 ------------- 2 files changed, 14 insertions(+), 18 deletions(-) diff --git a/numpy/core/src/common/npy_cblas.h b/numpy/core/src/common/npy_cblas.h index c0441e81e781..072993ec2be1 100644 --- a/numpy/core/src/common/npy_cblas.h +++ b/numpy/core/src/common/npy_cblas.h @@ -47,8 +47,10 @@ enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; #ifdef HAVE_BLAS_ILP64 #define CBLAS_INT npy_int64 +#define CBLAS_INT_MAX NPY_MAX_INT64 #else #define CBLAS_INT int +#define CBLAS_INT_MAX INT_MAX #endif #define BLASNAME(name) CBLAS_FUNC(name) @@ -73,17 +75,24 @@ blas_stride(npy_intp stride, unsigned itemsize) */ if (stride > 0 && (stride % itemsize) == 0) { stride /= itemsize; -#ifndef HAVE_BLAS_ILP64 - if (stride <= INT_MAX) { -#else - if (stride <= NPY_MAX_INT64) { -#endif + if (stride <= CBLAS_INT_MAX) { return stride; } } return 0; } +/* + * Define a chunksize for CBLAS. + * + * The chunksize is the greatest power of two less than CBLAS_INT_MAX. + */ +#if NPY_MAX_INTP > CBLAS_INT_MAX +# define NPY_CBLAS_CHUNK (CBLAS_INT_MAX / 2 + 1) +#else +# define NPY_CBLAS_CHUNK NPY_MAX_INTP +#endif + #ifdef __cplusplus } diff --git a/numpy/core/src/multiarray/common.h b/numpy/core/src/multiarray/common.h index 48ca320dd45f..71a742e728eb 100644 --- a/numpy/core/src/multiarray/common.h +++ b/numpy/core/src/multiarray/common.h @@ -290,19 +290,6 @@ npy_memchr(char * haystack, char needle, return p; } -/* - * Define a chunksize for CBLAS. CBLAS counts in integers. - */ -#if NPY_MAX_INTP > INT_MAX -# ifndef HAVE_BLAS_ILP64 -# define NPY_CBLAS_CHUNK (INT_MAX / 2 + 1) -# else -# define NPY_CBLAS_CHUNK (NPY_MAX_INT64 / 2 + 1) -# endif -#else -# define NPY_CBLAS_CHUNK NPY_MAX_INTP -#endif - #include "ucsnarrow.h" /* From ae7eca9be44cad3eb04a73e20806d061f7832754 Mon Sep 17 00:00:00 2001 From: Philippe Ombredanne Date: Thu, 3 Sep 2020 17:41:32 +0200 Subject: [PATCH 09/13] DOC: Use SPDX license expressions with correct license (gh-17238) * Use SPDX license expressions with correct license tools/npy_tempita/license.txt license is MIT not a "BSD Derived" Also use SPDX license identifiers and expressions for clarity Based on original report at https://github.com/nexB/scancode-toolkit/issues/2189 Reported-by: Frank Viernau Signed-off-by: Philippe Ombredanne * Use correct case for BSD licenses identifers Reported-by: Sebastian Berg Signed-off-by: Philippe Ombredanne --- LICENSES_bundled.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/LICENSES_bundled.txt b/LICENSES_bundled.txt index ea349c7ee8de..e9c66d1dcfb6 100644 --- a/LICENSES_bundled.txt +++ b/LICENSES_bundled.txt @@ -3,22 +3,22 @@ compatibly licensed. We list these here. Name: Numpydoc Files: doc/sphinxext/numpydoc/* -License: 2-clause BSD +License: BSD-2-Clause For details, see doc/sphinxext/LICENSE.txt Name: scipy-sphinx-theme Files: doc/scipy-sphinx-theme/* -License: 3-clause BSD, PSF and Apache 2.0 +License: BSD-3-Clause AND PSF-2.0 AND Apache-2.0 For details, see doc/scipy-sphinx-theme/LICENSE.txt Name: lapack-lite Files: numpy/linalg/lapack_lite/* -License: 3-clause BSD +License: BSD-3-Clause For details, see numpy/linalg/lapack_lite/LICENSE.txt Name: tempita Files: tools/npy_tempita/* -License: BSD derived +License: MIT For details, see tools/npy_tempita/license.txt Name: dragon4 From c6bf31a54c6a43127c9b9036171ec4d1db6435d3 Mon Sep 17 00:00:00 2001 From: Sebastian Berg Date: Thu, 3 Sep 2020 09:12:39 -0500 Subject: [PATCH 10/13] DOC: Fix the link to the quick-start in the old API functions --- doc/source/reference/random/legacy.rst | 2 +- numpy/random/mtrand.pyx | 84 +++++++++++++------------- 2 files changed, 43 insertions(+), 43 deletions(-) diff --git a/doc/source/reference/random/legacy.rst b/doc/source/reference/random/legacy.rst index 91b91dac89d9..6cf4775b81ba 100644 --- a/doc/source/reference/random/legacy.rst +++ b/doc/source/reference/random/legacy.rst @@ -133,7 +133,7 @@ Many of the RandomState methods above are exported as functions in - It uses a `RandomState` rather than the more modern `Generator`. For backward compatible legacy reasons, we cannot change this. See -`random-quick-start`. +:ref:`random-quick-start`. .. autosummary:: :toctree: generated/ diff --git a/numpy/random/mtrand.pyx b/numpy/random/mtrand.pyx index 169ed5f0e3fb..5f3440d5981e 100644 --- a/numpy/random/mtrand.pyx +++ b/numpy/random/mtrand.pyx @@ -383,7 +383,7 @@ cdef class RandomState: .. note:: New code should use the ``random`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -453,7 +453,7 @@ cdef class RandomState: .. note:: New code should use the ``beta`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -503,7 +503,7 @@ cdef class RandomState: .. note:: New code should use the ``exponential`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -552,7 +552,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_exponential`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -653,7 +653,7 @@ cdef class RandomState: .. note:: New code should use the ``integers`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -774,7 +774,7 @@ cdef class RandomState: .. note:: New code should use the ``bytes`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -812,7 +812,7 @@ cdef class RandomState: .. note:: New code should use the ``choice`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1014,7 +1014,7 @@ cdef class RandomState: .. note:: New code should use the ``uniform`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1182,7 +1182,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_normal`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. If positive int_like arguments are provided, `randn` generates an array of shape ``(d0, d1, ..., dn)``, filled @@ -1336,7 +1336,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_normal`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1411,7 +1411,7 @@ cdef class RandomState: .. note:: New code should use the ``normal`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1511,7 +1511,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_gamma`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1592,7 +1592,7 @@ cdef class RandomState: .. note:: New code should use the ``gamma`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1681,7 +1681,7 @@ cdef class RandomState: .. note:: New code should use the ``f`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1769,7 +1769,7 @@ cdef class RandomState: .. note:: New code should use the ``noncentral_f`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1854,7 +1854,7 @@ cdef class RandomState: .. note:: New code should use the ``chisquare`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -1927,7 +1927,7 @@ cdef class RandomState: .. note:: New code should use the ``noncentral_chisquare`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2013,7 +2013,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_cauchy`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2089,7 +2089,7 @@ cdef class RandomState: .. note:: New code should use the ``standard_t`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2194,7 +2194,7 @@ cdef class RandomState: .. note:: New code should use the ``vonmises`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2292,7 +2292,7 @@ cdef class RandomState: .. note:: New code should use the ``pareto`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2386,7 +2386,7 @@ cdef class RandomState: .. note:: New code should use the ``weibull`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2482,7 +2482,7 @@ cdef class RandomState: .. note:: New code should use the ``power`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2593,7 +2593,7 @@ cdef class RandomState: .. note:: New code should use the ``laplace`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2684,7 +2684,7 @@ cdef class RandomState: .. note:: New code should use the ``gumbel`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2806,7 +2806,7 @@ cdef class RandomState: .. note:: New code should use the ``logistic`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -2893,7 +2893,7 @@ cdef class RandomState: .. note:: New code should use the ``lognormal`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3006,7 +3006,7 @@ cdef class RandomState: .. note:: New code should use the ``rayleigh`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3088,7 +3088,7 @@ cdef class RandomState: .. note:: New code should use the ``wald`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3161,7 +3161,7 @@ cdef class RandomState: .. note:: New code should use the ``triangular`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3268,7 +3268,7 @@ cdef class RandomState: .. note:: New code should use the ``binomial`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3418,7 +3418,7 @@ cdef class RandomState: .. note:: New code should use the ``negative_binomial`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3503,7 +3503,7 @@ cdef class RandomState: .. note:: New code should use the ``poisson`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3589,7 +3589,7 @@ cdef class RandomState: .. note:: New code should use the ``zipf`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3679,7 +3679,7 @@ cdef class RandomState: .. note:: New code should use the ``geometric`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3733,7 +3733,7 @@ cdef class RandomState: .. note:: New code should use the ``hypergeometric`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3864,7 +3864,7 @@ cdef class RandomState: .. note:: New code should use the ``logseries`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -3957,7 +3957,7 @@ cdef class RandomState: .. note:: New code should use the ``multivariate_normal`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -4131,7 +4131,7 @@ cdef class RandomState: .. note:: New code should use the ``multinomial`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -4249,7 +4249,7 @@ cdef class RandomState: .. note:: New code should use the ``dirichlet`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -4395,7 +4395,7 @@ cdef class RandomState: .. note:: New code should use the ``shuffle`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- @@ -4490,7 +4490,7 @@ cdef class RandomState: .. note:: New code should use the ``permutation`` method of a ``default_rng()`` - instance instead; see `random-quick-start`. + instance instead; please see the :ref:`random-quick-start`. Parameters ---------- From 73fb919a798625a8f29e6c2f1e37ced33057a792 Mon Sep 17 00:00:00 2001 From: Stephan Loyd Date: Tue, 11 Aug 2020 23:29:15 +0800 Subject: [PATCH 11/13] fix pickling array size >2G (gh-17045) --- numpy/core/src/multiarray/methods.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c index 8b4009edf334..9cb4555f99a1 100644 --- a/numpy/core/src/multiarray/methods.c +++ b/numpy/core/src/multiarray/methods.c @@ -1614,7 +1614,7 @@ _getlist_pkl(PyArrayObject *self) } while (iter->index < iter->size) { theobject = getitem(iter->dataptr, self); - PyList_SET_ITEM(list, (int) iter->index, theobject); + PyList_SET_ITEM(list, iter->index, theobject); PyArray_ITER_NEXT(iter); } Py_DECREF(iter); @@ -1634,7 +1634,7 @@ _setlist_pkl(PyArrayObject *self, PyObject *list) return -1; } while(iter->index < iter->size) { - theobject = PyList_GET_ITEM(list, (int) iter->index); + theobject = PyList_GET_ITEM(list, iter->index); setitem(theobject, iter->dataptr, self); PyArray_ITER_NEXT(iter); } From b879d5f2219bbbe1edf6d1143beff3a441908bf9 Mon Sep 17 00:00:00 2001 From: Charles Harris Date: Tue, 8 Sep 2020 13:02:41 -0600 Subject: [PATCH 12/13] REL: Prepare for the NumPy 1.19.2 release. - Update mailmap - Update 1.19.2-notes.rst - Create 1.19.2-changelog.rst --- .mailmap | 1 + doc/changelog/1.19.2-changelog.rst | 30 ++++++++ .../upcoming_changes/16986.improvement.rst | 7 -- doc/source/release/1.19.2-notes.rst | 68 +++++++++++-------- 4 files changed, 71 insertions(+), 35 deletions(-) create mode 100644 doc/changelog/1.19.2-changelog.rst delete mode 100644 doc/release/upcoming_changes/16986.improvement.rst diff --git a/.mailmap b/.mailmap index ae221c0202b2..5b341595500d 100644 --- a/.mailmap +++ b/.mailmap @@ -232,6 +232,7 @@ Shota Kawabuchi skwbc siavashserver Simon Gasse sgasse Søren Rasmussen sorenrasmussenai <47032123+sorenrasmussenai@users.noreply.github.com> +Stefan Behnel scoder Stefan van der Walt Stefan van der Walt Stefan van der Walt Stefan van der Walt Stephan Hoyer Stephan Hoyer diff --git a/doc/changelog/1.19.2-changelog.rst b/doc/changelog/1.19.2-changelog.rst new file mode 100644 index 000000000000..47db1dd59cd7 --- /dev/null +++ b/doc/changelog/1.19.2-changelog.rst @@ -0,0 +1,30 @@ + +Contributors +============ + +A total of 8 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. + +* Charles Harris +* Matti Picus +* Pauli Virtanen +* Philippe Ombredanne + +* Sebastian Berg +* Stefan Behnel + +* Stephan Loyd + +* Zac Hatfield-Dodds + +Pull requests merged +==================== + +A total of 9 pull requests were merged for this release. + +* `#16959 `__: TST: Change aarch64 to arm64 in travis.yml. +* `#16998 `__: MAINT: Configure hypothesis in ``np.test()`` for determinism,... +* `#17000 `__: BLD: pin setuptools < 49.2.0 +* `#17015 `__: ENH: Add NumPy declarations to be used by Cython 3.0+ +* `#17125 `__: BUG: Remove non-threadsafe sigint handling from fft calculation +* `#17243 `__: BUG: core: fix ilp64 blas dot/vdot/... for strides > int32 max +* `#17244 `__: DOC: Use SPDX license expressions with correct license +* `#17245 `__: DOC: Fix the link to the quick-start in the old API functions +* `#17272 `__: BUG: fix pickling of arrays larger than 2GiB diff --git a/doc/release/upcoming_changes/16986.improvement.rst b/doc/release/upcoming_changes/16986.improvement.rst deleted file mode 100644 index 391322d9db99..000000000000 --- a/doc/release/upcoming_changes/16986.improvement.rst +++ /dev/null @@ -1,7 +0,0 @@ -Add NumPy declarations for Cython 3.0 and later ------------------------------------------------ - -The pxd declarations for Cython 3.0 were improved to avoid using deprecated -NumPy C-API features. Extension modules built with Cython 3.0+ that use NumPy -can now set the C macro ``NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION`` to avoid -C compiler warnings about deprecated API usage. diff --git a/doc/source/release/1.19.2-notes.rst b/doc/source/release/1.19.2-notes.rst index eda1976f5a7a..1267d5eb1e11 100644 --- a/doc/source/release/1.19.2-notes.rst +++ b/doc/source/release/1.19.2-notes.rst @@ -4,42 +4,54 @@ NumPy 1.19.2 Release Notes ========================== +NumPy 1.19.2 fixes several bugs, prepares for the upcoming Cython 3.x release. +and pins setuptools to keep distutils working while upstream modifications are +ongoing. The aarch64 wheels are built with the latest manylinux2014 release +that fixes the problem of differing page sizes used by different linux distros. -Highlights -========== +This release supports Python 3.6-3.8. Cython >= 0.29.21 needs to be used when +building with Python 3.9 for testing purposes. +There is a known problem with Windows 10 version=2004 and OpenBLAS svd that we +are trying to debug. If you are running that Windows version you should use a +NumPy version that links to the MKL library, earlier Windows versions are fine. -New functions -============= - - -Deprecations +Improvements ============ +Add NumPy declarations for Cython 3.0 and later +----------------------------------------------- +The pxd declarations for Cython 3.0 were improved to avoid using deprecated +NumPy C-API features. Extension modules built with Cython 3.0+ that use NumPy +can now set the C macro ``NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION`` to avoid +C compiler warnings about deprecated API usage. -Future Changes -============== - - -Expired deprecations -==================== - - -Compatibility notes -=================== - - -C API changes -============= - - -New Features +Contributors ============ +A total of 8 people contributed to this release. People with a "+" by their +names contributed a patch for the first time. -Improvements -============ +* Charles Harris +* Matti Picus +* Pauli Virtanen +* Philippe Ombredanne + +* Sebastian Berg +* Stefan Behnel + +* Stephan Loyd + +* Zac Hatfield-Dodds +Pull requests merged +==================== -Changes -======= +A total of 9 pull requests were merged for this release. + +* `#16959 `__: TST: Change aarch64 to arm64 in travis.yml. +* `#16998 `__: MAINT: Configure hypothesis in ``np.test()`` for determinism,... +* `#17000 `__: BLD: pin setuptools < 49.2.0 +* `#17015 `__: ENH: Add NumPy declarations to be used by Cython 3.0+ +* `#17125 `__: BUG: Remove non-threadsafe sigint handling from fft calculation +* `#17243 `__: BUG: core: fix ilp64 blas dot/vdot/... for strides > int32 max +* `#17244 `__: DOC: Use SPDX license expressions with correct license +* `#17245 `__: DOC: Fix the link to the quick-start in the old API functions +* `#17272 `__: BUG: fix pickling of arrays larger than 2GiB From 68752f786df542d340f25c41a8920d9b2aed66cf Mon Sep 17 00:00:00 2001 From: Charles Harris Date: Wed, 9 Sep 2020 18:16:45 -0600 Subject: [PATCH 13/13] REL: NumPy 1.19.2 release. --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 1fa2eb299b33..7768e3371fce 100755 --- a/setup.py +++ b/setup.py @@ -56,7 +56,7 @@ MAJOR = 1 MINOR = 19 MICRO = 2 -ISRELEASED = False +ISRELEASED = True VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO)