search

jochym / Elastic

A module for ASE for elastic constants calculation.
GNU General Public License v3.0
33 stars 22 forks source link

Pin numpy to latest version 1.16.2 #50

Closed pyup-bot closed 3 months ago

pyup-bot commented 5 years ago

This PR pins numpy to the latest release 1.16.2.

Changelog ### 1.16.1 ``` ========================== The NumPy 1.16.1 release fixes bugs reported against the 1.16.0 release, and also backports several enhancements from master that seem appropriate for a release series that is the last to support Python 2.7. The wheels on PyPI are linked with OpenBLAS v0.3.4+, which should fix the known threading issues found in previous OpenBLAS versions. Downstream developers building this release should use Cython >= 0.29.2 and, if using OpenBLAS, OpenBLAS > v0.3.4. If you are installing using pip, you may encounter a problem with older installed versions of NumPy that pip did not delete becoming mixed with the current version, resulting in an ``ImportError``. That problem is particularly common on Debian derived distributions due to a modified pip. The fix is to make sure all previous NumPy versions installed by pip have been removed. See `12736 <https://github.com/numpy/numpy/issues/12736>`__ for discussion of the issue. Note that previously this problem resulted in an ``AttributeError``. Contributors ============ A total of 16 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Antoine Pitrou * Arcesio Castaneda Medina + * Charles Harris * Chris Markiewicz + * Christoph Gohlke * Christopher J. Markiewicz + * Daniel Hrisca + * EelcoPeacs + * Eric Wieser * Kevin Sheppard * Matti Picus * OBATA Akio + * Ralf Gommers * Sebastian Berg * Stephan Hoyer * Tyler Reddy Enhancements ============ * `12767 <https://github.com/numpy/numpy/pull/12767>`__: ENH: add mm->q floordiv * `12768 <https://github.com/numpy/numpy/pull/12768>`__: ENH: port np.core.overrides to C for speed * `12769 <https://github.com/numpy/numpy/pull/12769>`__: ENH: Add np.ctypeslib.as_ctypes_type(dtype), improve `np.ctypeslib.as_ctypes` * `12773 <https://github.com/numpy/numpy/pull/12773>`__: ENH: add "max difference" messages to np.testing.assert_array_equal... * `12820 <https://github.com/numpy/numpy/pull/12820>`__: ENH: Add mm->qm divmod * `12890 <https://github.com/numpy/numpy/pull/12890>`__: ENH: add _dtype_ctype to namespace for freeze analysis Compatibility notes =================== * The changed error message emited by array comparison testing functions may affect doctests. See below for detail. * Casting from double and single denormals to float16 has been corrected. In some rare cases, this may result in results being rounded up instead of down, changing the last bit (ULP) of the result. New Features ============ divmod operation is now supported for two ``timedelta64`` operands ------------------------------------------------------------------ The divmod operator now handles two ``np.timedelta64`` operands, with type signature ``mm->qm``. Improvements ============ Further improvements to ``ctypes`` support in ``np.ctypeslib`` -------------------------------------------------------------- A new ``np.ctypeslib.as_ctypes_type`` function has been added, which can be used to converts a `dtype` into a best-guess `ctypes` type. Thanks to this new function, ``np.ctypeslib.as_ctypes`` now supports a much wider range of array types, including structures, booleans, and integers of non-native endianness. Array comparison assertions include maximum differences ------------------------------------------------------- Error messages from array comparison tests such as `np.testing.assert_allclose` now include "max absolute difference" and "max relative difference," in addition to the previous "mismatch" percentage. This information makes it easier to update absolute and relative error tolerances. Changes ======= ``timedelta64 % 0`` behavior adjusted to return ``NaT`` ------------------------------------------------------- The modulus operation with two ``np.timedelta64`` operands now returns ``NaT`` in the case of division by zero, rather than returning zero ========================== ``` ### 1.16.0 ``` ========================== This NumPy release is the last one to support Python 2.7 and will be maintained as a long term release with bug fixes until 2020. Support for Python 3.4 been dropped, the supported Python versions are 2.7 and 3.5-3.7. The wheels on PyPI are linked with OpenBLAS v0.3.4+, which should fix the known threading issues found in previous OpenBLAS versions. Downstream developers building this release should use Cython >= 0.29 and, if using OpenBLAS, OpenBLAS > v0.3.4. This release has seen a lot of refactoring and features many bug fixes, improved code organization, and better cross platform compatibility. Not all of these improvements will be visible to users, but they should help make maintenance easier going forward. Highlights ========== * Experimental (opt-in only) support for overriding numpy functions, see ``__array_function__`` below. * The ``matmul`` function is now a ufunc. This provides better performance and allows overriding with ``__array_ufunc__``. * Improved support for the ARM and POWER architectures. * Improved support for AIX and PyPy. * Improved interop with ctypes. * Improved support for PEP 3118. New functions ============= * New functions added to the `numpy.lib.recfuntions` module to ease the structured assignment changes: * ``assign_fields_by_name`` * ``structured_to_unstructured`` * ``unstructured_to_structured`` * ``apply_along_fields`` * ``require_fields`` See the user guide at <https://docs.scipy.org/doc/numpy/user/basics.rec.html> for more info. New deprecations ================ * The type dictionaries `numpy.core.typeNA` and `numpy.core.sctypeNA` are deprecated. They were buggy and not documented and will be removed in the 1.18 release. Use`numpy.sctypeDict` instead. * The `numpy.asscalar` function is deprecated. It is an alias to the more powerful `numpy.ndarray.item`, not tested, and fails for scalars. * The `numpy.set_array_ops` and `numpy.get_array_ops` functions are deprecated. As part of `NEP 15`, they have been deprecated along with the C-API functions :c:func:`PyArray_SetNumericOps` and :c:func:`PyArray_GetNumericOps`. Users who wish to override the inner loop functions in built-in ufuncs should use :c:func:`PyUFunc_ReplaceLoopBySignature`. * The `numpy.unravel_index` keyword argument ``dims`` is deprecated, use ``shape`` instead. * The `numpy.histogram` ``normed`` argument is deprecated. It was deprecated previously, but no warning was issued. * The ``positive`` operator (``+``) applied to non-numerical arrays is deprecated. See below for details. * Passing an iterator to the stack functions is deprecated Expired deprecations ==================== * NaT comparisons now return ``False`` without a warning, finishing a deprecation cycle begun in NumPy 1.11. * ``np.lib.function_base.unique`` was removed, finishing a deprecation cycle begun in NumPy 1.4. Use `numpy.unique` instead. * multi-field indexing now returns views instead of copies, finishing a deprecation cycle begun in NumPy 1.7. The change was previously attempted in NumPy 1.14 but reverted until now. * ``np.PackageLoader`` and ``np.pkgload`` have been removed. These were deprecated in 1.10, had no tests, and seem to no longer work in 1.15. Future changes ============== * NumPy 1.17 will drop support for Python 2.7. Compatibility notes =================== f2py script on Windows ---------------------- On Windows, the installed script for running f2py is now an ``.exe`` file rather than a ``*.py`` file and should be run from the command line as ``f2py`` whenever the ``Scripts`` directory is in the path. Running ``f2py`` as a module ``python -m numpy.f2py [...]`` will work without path modification in any version of NumPy. NaT comparisons --------------- Consistent with the behavior of NaN, all comparisons other than inequality checks with datetime64 or timedelta64 NaT ("not-a-time") values now always return ``False``, and inequality checks with NaT now always return ``True``. This includes comparisons beteween NaT values. For compatibility with the old behavior, use ``np.isnat`` to explicitly check for NaT or convert datetime64/timedelta64 arrays with ``.astype(np.int64)`` before making comparisons. complex64/128 alignment has changed ----------------------------------- The memory alignment of complex types is now the same as a C-struct composed of two floating point values, while before it was equal to the size of the type. For many users (for instance on x64/unix/gcc) this means that complex64 is now 4-byte aligned instead of 8-byte aligned. An important consequence is that aligned structured dtypes may now have a different size. For instance, ``np.dtype('c8,u1', align=True)`` used to have an itemsize of 16 (on x64/gcc) but now it is 12. More in detail, the complex64 type now has the same alignment as a C-struct ``struct {float r, i;}``, according to the compiler used to compile numpy, and similarly for the complex128 and complex256 types. nd_grid __len__ removal ----------------------- ``len(np.mgrid)`` and ``len(np.ogrid)`` are now considered nonsensical and raise a ``TypeError``. ``np.unravel_index`` now accepts ``shape`` keyword argument ----------------------------------------------------------- Previously, only the ``dims`` keyword argument was accepted for specification of the shape of the array to be used for unraveling. ``dims`` remains supported, but is now deprecated. multi-field views return a view instead of a copy ------------------------------------------------- Indexing a structured array with multiple fields, e.g., ``arr[['f1', 'f3']]``, returns a view into the original array instead of a copy. The returned view will often have extra padding bytes corresponding to intervening fields in the original array, unlike before, which will affect code such as ``arr[['f1', 'f3']].view('float64')``. This change has been planned since numpy 1.7. Operations hitting this path have emitted ``FutureWarnings`` since then. Additional ``FutureWarnings`` about this change were added in 1.12. To help users update their code to account for these changes, a number of functions have been added to the ``numpy.lib.recfunctions`` module which safely allow such operations. For instance, the code above can be replaced with ``structured_to_unstructured(arr[['f1', 'f3']], dtype='float64')``. See the "accessing multiple fields" section of the `user guide <https://docs.scipy.org/doc/numpy/user/basics.rec.htmlaccessing-multiple-fields>`__. C API changes ============= The :c:data:`NPY_API_VERSION` was incremented to 0x0000D, due to the addition of: * :c:member:`PyUFuncObject.core_dim_flags` * :c:member:`PyUFuncObject.core_dim_sizes` * :c:member:`PyUFuncObject.identity_value` * :c:function:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity` New Features ============ Integrated squared error (ISE) estimator added to ``histogram`` --------------------------------------------------------------- This method (``bins='stone'``) for optimizing the bin number is a generalization of the Scott's rule. The Scott's rule assumes the distribution is approximately Normal, while the ISE_ is a non-parametric method based on cross-validation. .. _ISE: https://en.wikipedia.org/wiki/HistogramMinimizing_cross-validation_estimated_squared_error ``max_rows`` keyword added for ``np.loadtxt`` --------------------------------------------- New keyword ``max_rows`` in `numpy.loadtxt` sets the maximum rows of the content to be read after ``skiprows``, as in `numpy.genfromtxt`. modulus operator support added for ``np.timedelta64`` operands -------------------------------------------------------------- The modulus (remainder) operator is now supported for two operands of type ``np.timedelta64``. The operands may have different units and the return value will match the type of the operands. Improvements ============ no-copy pickling of numpy arrays -------------------------------- Up to protocol 4, numpy array pickling created 2 spurious copies of the data being serialized. With pickle protocol 5, and the ``PickleBuffer`` API, a large variety of numpy arrays can now be serialized without any copy using out-of-band buffers, and with one less copy using in-band buffers. This results, for large arrays, in an up to 66% drop in peak memory usage. build shell independence ------------------------ NumPy builds should no longer interact with the host machine shell directly. ``exec_command`` has been replaced with ``subprocess.check_output`` where appropriate. `np.polynomial.Polynomial` classes render in LaTeX in Jupyter notebooks ----------------------------------------------------------------------- When used in a front-end that supports it, `Polynomial` instances are now rendered through LaTeX. The current format is experimental, and is subject to change. ``randint`` and ``choice`` now work on empty distributions ---------------------------------------------------------- Even when no elements needed to be drawn, ``np.random.randint`` and ``np.random.choice`` raised an error when the arguments described an empty distribution. This has been fixed so that e.g. ``np.random.choice([], 0) == np.array([], dtype=float64)``. ``linalg.lstsq``, ``linalg.qr``, and ``linalg.svd`` now work with empty arrays ------------------------------------------------------------------------------ Previously, a ``LinAlgError`` would be raised when an empty matrix/empty matrices (with zero rows and/or columns) is/are passed in. Now outputs of appropriate shapes are returned. Chain exceptions to give better error messages for invalid PEP3118 format strings --------------------------------------------------------------------------------- This should help track down problems. Einsum optimization path updates and efficiency improvements ------------------------------------------------------------ Einsum was synchronized with the current upstream work. `numpy.angle` and `numpy.expand_dims` now work on ``ndarray`` subclasses ------------------------------------------------------------------------ In particular, they now work for masked arrays. ``NPY_NO_DEPRECATED_API`` compiler warning suppression ------------------------------------------------------ Setting ``NPY_NO_DEPRECATED_API`` to a value of 0 will suppress the current compiler warnings when the deprecated numpy API is used. ``np.diff`` Added kwargs prepend and append ------------------------------------------- New kwargs ``prepend`` and ``append``, allow for values to be inserted on either end of the differences. Similar to options for `ediff1d`. Now the inverse of `cumsum` can be obtained easily via ``prepend=0``. ARM support updated ------------------- Support for ARM CPUs has been updated to accommodate 32 and 64 bit targets, and also big and little endian byte ordering. AARCH32 memory alignment issues have been addressed. CI testing has been expanded to include AARCH64 targets via the services of shippable.com. Appending to build flags ------------------------ `numpy.distutils` has always overridden rather than appended to `LDFLAGS` and other similar such environment variables for compiling Fortran extensions. Now, if the `NPY_DISTUTILS_APPEND_FLAGS` environment variable is set to 1, the behavior will be appending. This applied to: `LDFLAGS`, `F77FLAGS`, `F90FLAGS`, `FREEFLAGS`, `FOPT`, `FDEBUG`, and `FFLAGS`. See gh-11525 for more details. Generalized ufunc signatures now allow fixed-size dimensions ------------------------------------------------------------ By using a numerical value in the signature of a generalized ufunc, one can indicate that the given function requires input or output to have dimensions with the given size. E.g., the signature of a function that converts a polar angle to a two-dimensional cartesian unit vector would be ``()->(2)``; that for one that converts two spherical angles to a three-dimensional unit vector would be ``(),()->(3)``; and that for the cross product of two three-dimensional vectors would be ``(3),(3)->(3)``. Note that to the elementary function these dimensions are not treated any differently from variable ones indicated with a name starting with a letter; the loop still is passed the corresponding size, but it can now count on that size being equal to the fixed one given in the signature. Generalized ufunc signatures now allow flexible dimensions ---------------------------------------------------------- Some functions, in particular numpy's implementation of ` as ``matmul``, are very similar to generalized ufuncs in that they operate over core dimensions, but one could not present them as such because they were able to deal with inputs in which a dimension is missing. To support this, it is now allowed to postfix a dimension name with a question mark to indicate that the dimension does not necessarily have to be present. With this addition, the signature for ``matmul`` can be expressed as ``(m?,n),(n,p?)->(m?,p?)``. This indicates that if, e.g., the second operand has only one dimension, for the purposes of the elementary function it will be treated as if that input has core shape ``(n, 1)``, and the output has the corresponding core shape of ``(m, 1)``. The actual output array, however, has the flexible dimension removed, i.e., it will have shape ``(..., m)``. Similarly, if both arguments have only a single dimension, the inputs will be presented as having shapes ``(1, n)`` and ``(n, 1)`` to the elementary function, and the output as ``(1, 1)``, while the actual output array returned will have shape ``()``. In this way, the signature allows one to use a single elementary function for four related but different signatures, ``(m,n),(n,p)->(m,p)``, ``(n),(n,p)->(p)``, ``(m,n),(n)->(m)`` and ``(n),(n)->()``. ``np.clip`` and the ``clip`` method check for memory overlap ------------------------------------------------------------ The ``out`` argument to these functions is now always tested for memory overlap to avoid corrupted results when memory overlap occurs. New value ``unscaled`` for option ``cov`` in ``np.polyfit`` ----------------------------------------------------------- A further possible value has been added to the ``cov`` parameter of the ``np.polyfit`` function. With ``cov='unscaled'`` the scaling of the covariance matrix is disabled completely (similar to setting ``absolute_sigma=True`` in ``scipy.optimize.curve_fit``). This would be useful in occasions, where the weights are given by 1/sigma with sigma being the (known) standard errors of (Gaussian distributed) data points, in which case the unscaled matrix is already a correct estimate for the covariance matrix. Detailed docstrings for scalar numeric types -------------------------------------------- The ``help`` function, when applied to numeric types such as `numpy.intc`, `numpy.int_`, and `numpy.longlong`, now lists all of the aliased names for that type, distinguishing between platform -dependent and -independent aliases. ``__module__`` attribute now points to public modules ----------------------------------------------------- The ``__module__`` attribute on most NumPy functions has been updated to refer to the preferred public module from which to access a function, rather than the module in which the function happens to be defined. This produces more informative displays for functions in tools such as IPython, e.g., instead of ``<function 'numpy.core.fromnumeric.sum'>`` you now see ``<function 'numpy.sum'>``. Large allocations marked as suitable for transparent hugepages -------------------------------------------------------------- On systems that support transparent hugepages over the madvise system call numpy now marks that large memory allocations can be backed by hugepages which reduces page fault overhead and can in some fault heavy cases improve performance significantly. On Linux the setting for huge pages to be used, `/sys/kernel/mm/transparent_hugepage/enabled`, must be at least `madvise`. Systems which already have it set to `always` will not see much difference as the kernel will automatically use huge pages where appropriate. Users of very old Linux kernels (~3.x and older) should make sure that `/sys/kernel/mm/transparent_hugepage/defrag` is not set to `always` to avoid performance problems due concurrency issues in the memory defragmentation. Alpine Linux (and other musl c library distros) support ------------------------------------------------------- We now default to use `fenv.h` for floating point status error reporting. Previously we had a broken default that sometimes would not report underflow, overflow, and invalid floating point operations. Now we can support non-glibc distrubutions like Alpine Linux as long as they ship `fenv.h`. Speedup ``np.block`` for large arrays ------------------------------------- Large arrays (greater than ``512 * 512``) now use a blocking algorithm based on copying the data directly into the appropriate slice of the resulting array. This results in significant speedups for these large arrays, particularly for arrays being blocked along more than 2 dimensions. ``arr.ctypes.data_as(...)`` holds a reference to arr ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Previously the caller was responsible for keeping the array alive for the lifetime of the pointer. Speedup ``np.take`` for read-only arrays ---------------------------------------- The implementation of ``np.take`` no longer makes an unnecessary copy of the source array when its ``writeable`` flag is set to ``False``. Support path-like objects for more functions -------------------------------------------- The ``np.core.records.fromfile`` function now supports ``pathlib.Path`` and other path-like objects in addition to a file object. Furthermore, the ``np.load`` function now also supports path-like objects when using memory mapping (``mmap_mode`` keyword argument). Better behaviour of ufunc identities during reductions ------------------------------------------------------ Universal functions have an ``.identity`` which is used when ``.reduce`` is called on an empty axis. As of this release, the logical binary ufuncs, `logical_and`, `logical_or`, and `logical_xor`, now have ``identity`` s of type `bool`, where previously they were of type `int`. This restores the 1.14 behavior of getting ``bool`` s when reducing empty object arrays with these ufuncs, while also keeping the 1.15 behavior of getting ``int`` s when reducing empty object arrays with arithmetic ufuncs like ``add`` and ``multiply``. Additionally, `logaddexp` now has an identity of ``-inf``, allowing it to be called on empty sequences, where previously it could not be. This is possible thanks to the new :c:function:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity`, which allows arbitrary values to be used as identities now. Improved conversion from ctypes objects --------------------------------------- Numpy has always supported taking a value or type from ``ctypes`` and converting it into an array or dtype, but only behaved correctly for simpler types. As of this release, this caveat is lifted - now: * The ``_pack_`` attribute of ``ctypes.Structure``, used to emulate C's ``__attribute__((packed))``, is respected. * Endianness of all ctypes objects is preserved * ``ctypes.Union`` is supported * Non-representable constructs raise exceptions, rather than producing dangerously incorrect results: * Bitfields are no longer interpreted as sub-arrays * Pointers are no longer replaced with the type that they point to A new ``ndpointer.contents`` member ----------------------------------- This matches the ``.contents`` member of normal ctypes arrays, and can be used to construct an ``np.array`` around the pointers contents. This replaces ``np.array(some_nd_pointer)``, which stopped working in 1.15. As a side effect of this change, ``ndpointer`` now supports dtypes with overlapping fields and padding. ``matmul`` is now a ``ufunc`` ----------------------------- `numpy.matmul` is now a ufunc which means that both the function and the ``__matmul__`` operator can now be overridden by ``__array_ufunc__``. Its implementation has also changed. It uses the same BLAS routines as `numpy.dot`, ensuring its performance is similar for large matrices. Start and stop arrays for ``linspace``, ``logspace`` and ``geomspace`` ---------------------------------------------------------------------- These functions used to be limited to scalar stop and start values, but can now take arrays, which will be properly broadcast and result in an output which has one axis prepended. This can be used, e.g., to obtain linearly interpolated points between sets of points. CI extended with additional services ------------------------------------ We now use additional free CI services, thanks to the companies that provide: * Codecoverage testing via codecov.io * Arm testing via shippable.com * Additional test runs on azure pipelines These are in addition to our continued use of travis, appveyor (for wheels) and LGTM Changes ======= Comparison ufuncs will now error rather than return NotImplemented ------------------------------------------------------------------ Previously, comparison ufuncs such as ``np.equal`` would return `NotImplemented` if their arguments had structured dtypes, to help comparison operators such as ``__eq__`` deal with those. This is no longer needed, as the relevant logic has moved to the comparison operators proper (which thus do continue to return `NotImplemented` as needed). Hence, like all other ufuncs, the comparison ufuncs will now error on structured dtypes. Positive will now raise a deprecation warning for non-numerical arrays ---------------------------------------------------------------------- Previously, ``+array`` unconditionally returned a copy. Now, it will raise a ``DeprecationWarning`` if the array is not numerical (i.e., if ``np.positive(array)`` raises a ``TypeError``. For ``ndarray`` subclasses that override the default ``__array_ufunc__`` implementation, the ``TypeError`` is passed on. ``NDArrayOperatorsMixin`` now implements matrix multiplication -------------------------------------------------------------- Previously, ``np.lib.mixins.NDArrayOperatorsMixin`` did not implement the special methods for Python's matrix multiplication operator (`). This has changed now that ``matmul`` is a ufunc and can be overridden using ``__array_ufunc__``. The scaling of the covariance matrix in ``np.polyfit`` is different ------------------------------------------------------------------- So far, ``np.polyfit`` used a non-standard factor in the scaling of the the covariance matrix. Namely, rather than using the standard ``chisq/(M-N)``, it scaled it with ``chisq/(M-N-2)`` where M is the number of data points and N is the number of parameters. This scaling is inconsistent with other fitting programs such as e.g. ``scipy.optimize.curve_fit`` and was changed to ``chisq/(M-N)``. ``maximum`` and ``minimum`` no longer emit warnings --------------------------------------------------- As part of code introduced in 1.10, ``float32`` and ``float64`` set invalid float status when a Nan is encountered in `numpy.maximum` and `numpy.minimum`, when using SSE2 semantics. This caused a `RuntimeWarning` to sometimes be emitted. In 1.15 we fixed the inconsistencies which caused the warnings to become more conspicuous. Now no warnings will be emitted. Umath and multiarray c-extension modules merged into a single module -------------------------------------------------------------------- The two modules were merged, according to `NEP 15`_. Previously `np.core.umath` and `np.core.multiarray` were seperate c-extension modules. They are now python wrappers to the single `np.core/_multiarray_math` c-extension module. .. _`NEP 15` : http://www.numpy.org/neps/nep-0015-merge-multiarray-umath.html ``getfield`` validity checks extended ------------------------------------- `numpy.ndarray.getfield` now checks the dtype and offset arguments to prevent accessing invalid memory locations. NumPy functions now support overrides with ``__array_function__`` ----------------------------------------------------------------- NumPy has a new experimental mechanism for overriding the implementation of almost all NumPy functions on non-NumPy arrays by defining an ``__array_function__`` method, as described in `NEP 18`_. This feature is not yet been enabled by default, but has been released to facilitate experimentation by potential users. See the NEP for details on setting the appropriate environment variable. We expect the NumPy 1.17 release will enable overrides by default, which will also be more performant due to a new implementation written in C. .. _`NEP 18` : http://www.numpy.org/neps/nep-0018-array-function-protocol.html Arrays based off readonly buffers cannot be set ``writeable`` ------------------------------------------------------------- We now disallow setting the ``writeable`` flag True on arrays created from ``fromstring(readonly-buffer)``. ========================== ``` ### 1.15.4 ``` ========================== This is a bugfix release for bugs and regressions reported following the 1.15.3 release. The Python versions supported by this release are 2.7, 3.4-3.7. The wheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg problems reported for NumPy 1.14. Compatibility Note ================== The NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit binaries. That will also be the case in future releases. See `11625 <https://github.com/numpy/numpy/issues/11625>`__ for the related discussion. Those needing 32-bit support should look elsewhere or build from source. Contributors ============ A total of 4 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Charles Harris * Matti Picus * Sebastian Berg * bbbbbbbbba + Pull requests merged ==================== A total of 4 pull requests were merged for this release. * `12296 <https://github.com/numpy/numpy/pull/12296>`__: BUG: Dealloc cached buffer info * `12297 <https://github.com/numpy/numpy/pull/12297>`__: BUG: Fix fill value in masked array '==' and '!=' ops. * `12307 <https://github.com/numpy/numpy/pull/12307>`__: DOC: Correct the default value of `optimize` in `numpy.einsum` * `12320 <https://github.com/numpy/numpy/pull/12320>`__: REL: Prepare for the NumPy 1.15.4 release ========================== ``` ### 1.15.3 ``` ========================== This is a bugfix release for bugs and regressions reported following the 1.15.2 release. The Python versions supported by this release are 2.7, 3.4-3.7. The wheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg problems reported for NumPy 1.14. Compatibility Note ================== The NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit binaries. That will also be the case in future releases. See `11625 <https://github.com/numpy/numpy/issues/11625>`__ for the related discussion. Those needing 32-bit support should look elsewhere or build from source. Contributors ============ A total of 7 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Allan Haldane * Charles Harris * Jeroen Demeyer * Kevin Sheppard * Matthew Bowden + * Matti Picus * Tyler Reddy Pull requests merged ==================== A total of 12 pull requests were merged for this release. * `12080 <https://github.com/numpy/numpy/pull/12080>`__: MAINT: Blacklist some MSVC complex functions. * `12083 <https://github.com/numpy/numpy/pull/12083>`__: TST: Add azure CI testing to 1.15.x branch. * `12084 <https://github.com/numpy/numpy/pull/12084>`__: BUG: test_path() now uses Path.resolve() * `12085 <https://github.com/numpy/numpy/pull/12085>`__: TST, MAINT: Fix some failing tests on azure-pipelines mac and... * `12187 <https://github.com/numpy/numpy/pull/12187>`__: BUG: Fix memory leak in mapping.c * `12188 <https://github.com/numpy/numpy/pull/12188>`__: BUG: Allow boolean subtract in histogram * `12189 <https://github.com/numpy/numpy/pull/12189>`__: BUG: Fix in-place permutation * `12190 <https://github.com/numpy/numpy/pull/12190>`__: BUG: limit default for get_num_build_jobs() to 8 * `12191 <https://github.com/numpy/numpy/pull/12191>`__: BUG: OBJECT_to_* should check for errors * `12192 <https://github.com/numpy/numpy/pull/12192>`__: DOC: Prepare for NumPy 1.15.3 release. * `12237 <https://github.com/numpy/numpy/pull/12237>`__: BUG: Fix MaskedArray fill_value type conversion. * `12238 <https://github.com/numpy/numpy/pull/12238>`__: TST: Backport azure-pipeline testing fixes for Mac ========================= ``` ### 1.15.2 ``` ========================== This is a bugfix release for bugs and regressions reported following the 1.15.1 release. * The matrix PendingDeprecationWarning is now suppressed in pytest 3.8. * The new cached allocations machinery has been fixed to be thread safe. * The boolean indexing of subclasses now works correctly. * A small memory leak in PyArray_AdaptFlexibleDType has been fixed. The Python versions supported by this release are 2.7, 3.4-3.7. The wheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg problems reported for NumPy 1.14. Compatibility Note ================== The NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit binaries. That will also be the case in future releases. See `11625 <https://github.com/numpy/numpy/issues/11625>`__ for the related discussion. Those needing 32-bit support should look elsewhere or build from source. Contributors ============ A total of 4 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Charles Harris * Julian Taylor * Marten van Kerkwijk * Matti Picus Pull requests merged ==================== A total of 4 pull requests were merged for this release. * `11902 <https://github.com/numpy/numpy/pull/11902>`__: BUG: Fix matrix PendingDeprecationWarning suppression for pytest... * `11981 <https://github.com/numpy/numpy/pull/11981>`__: BUG: fix cached allocations without the GIL for 1.15.x * `11982 <https://github.com/numpy/numpy/pull/11982>`__: BUG: fix refcount leak in PyArray_AdaptFlexibleDType * `11992 <https://github.com/numpy/numpy/pull/11992>`__: BUG: Ensure boolean indexing of subclasses sets base correctly. ========================== ``` ### 1.15.1 ``` ========================== This is a bugfix release for bugs and regressions reported following the 1.15.0 release. * The annoying but harmless RuntimeWarning that "numpy.dtype size changed" has been suppressed. The long standing suppression was lost in the transition to pytest. * The update to Cython 0.28.3 exposed a problematic use of a gcc attribute used to prefer code size over speed in module initialization, possibly resulting in incorrect compiled code. This has been fixed in latest Cython but has been disabled here for safety. * Support for big-endian and ARMv8 architectures has been improved. The Python versions supported by this release are 2.7, 3.4-3.7. The wheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg problems reported for NumPy 1.14. Compatibility Note ================== The NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit binaries. That will also be the case in future releases. See `11625 <https://github.com/numpy/numpy/issues/11625>`__ for the related discussion. Those needing 32-bit support should look elsewhere or build from source. Contributors ============ A total of 7 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Charles Harris * Chris Billington * Elliott Sales de Andrade + * Eric Wieser * Jeremy Manning + * Matti Picus * Ralf Gommers Pull requests merged ==================== A total of 24 pull requests were merged for this release. * `11647 <https://github.com/numpy/numpy/pull/11647>`__: MAINT: Filter Cython warnings in ``__init__.py`` * `11648 <https://github.com/numpy/numpy/pull/11648>`__: BUG: Fix doc source links to unwrap decorators * `11657 <https://github.com/numpy/numpy/pull/11657>`__: BUG: Ensure singleton dimensions are not dropped when converting... * `11661 <https://github.com/numpy/numpy/pull/11661>`__: BUG: Warn on Nan in minimum,maximum for scalars * `11665 <https://github.com/numpy/numpy/pull/11665>`__: BUG: cython sometimes emits invalid gcc attribute * `11682 <https://github.com/numpy/numpy/pull/11682>`__: BUG: Fix regression in void_getitem * `11698 <https://github.com/numpy/numpy/pull/11698>`__: BUG: Make matrix_power again work for object arrays. * `11700 <https://github.com/numpy/numpy/pull/11700>`__: BUG: Add missing PyErr_NoMemory after failing malloc * `11719 <https://github.com/numpy/numpy/pull/11719>`__: BUG: Fix undefined functions on big-endian systems. * `11720 <https://github.com/numpy/numpy/pull/11720>`__: MAINT: Make einsum optimize default to False. * `11746 <https://github.com/numpy/numpy/pull/11746>`__: BUG: Fix regression in loadtxt for bz2 text files in Python 2. * `11757 <https://github.com/numpy/numpy/pull/11757>`__: BUG: Revert use of `console_scripts`. * `11758 <https://github.com/numpy/numpy/pull/11758>`__: BUG: Fix Fortran kind detection for aarch64 & s390x. * `11759 <https://github.com/numpy/numpy/pull/11759>`__: BUG: Fix printing of longdouble on ppc64le. * `11760 <https://github.com/numpy/numpy/pull/11760>`__: BUG: Fixes for unicode field names in Python 2 * `11761 <https://github.com/numpy/numpy/pull/11761>`__: BUG: Increase required cython version on python 3.7 * `11763 <https://github.com/numpy/numpy/pull/11763>`__: BUG: check return value of _buffer_format_string * `11775 <https://github.com/numpy/numpy/pull/11775>`__: MAINT: Make assert_array_compare more generic. * `11776 <https://github.com/numpy/numpy/pull/11776>`__: TST: Fix urlopen stubbing. * `11777 <https://github.com/numpy/numpy/pull/11777>`__: BUG: Fix regression in intersect1d. * `11779 <https://github.com/numpy/numpy/pull/11779>`__: BUG: Fix test sensitive to platform byte order. * `11781 <https://github.com/numpy/numpy/pull/11781>`__: BUG: Avoid signed overflow in histogram * `11785 <https://github.com/numpy/numpy/pull/11785>`__: BUG: Fix pickle and memoryview for datetime64, timedelta64 scalars * `11786 <https://github.com/numpy/numpy/pull/11786>`__: BUG: Deprecation triggers segfault ========================= ``` ### 1.15.0 ``` ========================== NumPy 1.15.0 is a release with an unusual number of cleanups, many deprecations of old functions, and improvements to many existing functions. Please read the detailed descriptions below to see if you are affected. For testing, we have switched to pytest as a replacement for the no longer maintained nose framework. The old nose based interface remains for downstream projects who may still be using it. The Python versions supported by this release are 2.7, 3.4-3.7. The wheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg problems reported for NumPy 1.14. Highlights ========== * NumPy has switched to pytest for testing. * A new `numpy.printoptions` context manager. * Many improvements to the histogram functions. * Support for unicode field names in python 2.7. * Improved support for PyPy. * Fixes and improvements to `numpy.einsum`. New functions ============= * `numpy.gcd` and `numpy.lcm`, to compute the greatest common divisor and least common multiple. * `numpy.ma.stack`, the `numpy.stack` array-joining function generalized to masked arrays. * `numpy.quantile` function, an interface to ``percentile`` without factors of 100 * `numpy.nanquantile` function, an interface to ``nanpercentile`` without factors of 100 * `numpy.printoptions`, a context manager that sets print options temporarily for the scope of the ``with`` block:: >>> with np.printoptions(precision=2): ... print(np.array([2.0]) / 3) [0.67] * `numpy.histogram_bin_edges`, a function to get the edges of the bins used by a histogram without needing to calculate the histogram. * C functions `npy_get_floatstatus_barrier` and `npy_clear_floatstatus_barrier` have been added to deal with compiler optimization changing the order of operations. See below for details. Deprecations ============ * Aliases of builtin `pickle` functions are deprecated, in favor of their unaliased ``pickle.<func>`` names: * `numpy.loads` * `numpy.core.numeric.load` * `numpy.core.numeric.loads` * `numpy.ma.loads`, `numpy.ma.dumps` * `numpy.ma.load`, `numpy.ma.dump` - these functions already failed on python 3 when called with a string. * Multidimensional indexing with anything but a tuple is deprecated. This means that the index list in ``ind = [slice(None), 0]; arr[ind]`` should be changed to a tuple, e.g., ``ind = [slice(None), 0]; arr[tuple(ind)]`` or ``arr[(slice(None), 0)]``. That change is necessary to avoid ambiguity in expressions such as ``arr[[[0, 1], [0, 1]]]``, currently interpreted as ``arr[array([0, 1]), array([0, 1])]``, that will be interpreted as ``arr[array([[0, 1], [0, 1]])]`` in the future. * Imports from the following sub-modules are deprecated, they will be removed at some future date. * `numpy.testing.utils` * `numpy.testing.decorators` * `numpy.testing.nosetester` * `numpy.testing.noseclasses` * `numpy.core.umath_tests` * Giving a generator to `numpy.sum` is now deprecated. This was undocumented behavior, but worked. Previously, it would calculate the sum of the generator expression. In the future, it might return a different result. Use ``np.sum(np.from_iter(generator))`` or the built-in Python ``sum`` instead. * Users of the C-API should call ``PyArrayResolveWriteBackIfCopy`` or ``PyArray_DiscardWritbackIfCopy`` on any array with the ``WRITEBACKIFCOPY`` flag set, before deallocating the array. A deprecation warning will be emitted if those calls are not used when needed. * Users of ``nditer`` should use the nditer object as a context manager anytime one of the iterator operands is writeable, so that numpy can manage writeback semantics, or should call ``it.close()``. A `RuntimeWarning` may be emitted otherwise in these cases. * The ``normed`` argument of ``np.histogram``, deprecated long ago in 1.6.0, now emits a ``DeprecationWarning``. Future Changes ============== * NumPy 1.16 will drop support for Python 3.4. * NumPy 1.17 will drop support for Python 2.7. Compatibility notes =================== Compiled testing modules renamed and made private ------------------------------------------------- The following compiled modules have been renamed and made private: * ``umath_tests`` -> ``_umath_tests`` * ``test_rational`` -> ``_rational_tests`` * ``multiarray_tests`` -> ``_multiarray_tests`` * ``struct_ufunc_test`` -> ``_struct_ufunc_tests`` * ``operand_flag_tests`` -> ``_operand_flag_tests`` The ``umath_tests`` module is still available for backwards compatibility, but will be removed in the future. The ``NpzFile`` returned by ``np.savez`` is now a ``collections.abc.Mapping`` ----------------------------------------------------------------------------- This means it behaves like a readonly dictionary, and has a new ``.values()`` method and ``len()`` implementation. For python 3, this means that ``.iteritems()``, ``.iterkeys()`` have been deprecated, and ``.keys()`` and ``.items()`` now return views and not lists. This is consistent with how the builtin ``dict`` type changed between python 2 and python 3. Under certain conditions, ``nditer`` must be used in a context manager ---------------------------------------------------------------------- When using an `numpy.nditer` with the ``"writeonly"`` or ``"readwrite"`` flags, there are some circumstances where nditer doesn't actually give you a view of the writable array. Instead, it gives you a copy, and if you make changes to the copy, nditer later writes those changes back into your actual array. Currently, this writeback occurs when the array objects are garbage collected, which makes this API error-prone on CPython and entirely broken on PyPy. Therefore, ``nditer`` should now be used as a context manager whenever it is used with writeable arrays, e.g., ``with np.nditer(...) as it: ...``. You may also explicitly call ``it.close()`` for cases where a context manager is unusable, for instance in generator expressions. Numpy has switched to using pytest instead of nose for testing -------------------------------------------------------------- The last nose release was 1.3.7 in June, 2015, and development of that tool has ended, consequently NumPy has now switched to using pytest. The old decorators and nose tools that were previously used by some downstream projects remain available, but will not be maintained. The standard testing utilities, ``assert_almost_equal`` and such, are not be affected by this change except for the nose specific functions ``import_nose`` and ``raises``. Those functions are not used in numpy, but are kept for downstream compatibility. Numpy no longer monkey-patches ``ctypes`` with ``__array_interface__`` ---------------------------------------------------------------------- Previously numpy added ``__array_interface__`` attributes to all the integer types from ``ctypes``. ``np.ma.notmasked_contiguous`` and ``np.ma.flatnotmasked_contiguous`` always return lists ----------------------------------------------------------------------------------------- This is the documented behavior, but previously the result could be any of slice, None, or list. All downstream users seem to check for the ``None`` result from ``flatnotmasked_contiguous`` and replace it with ``[]``. Those callers will continue to work as before. ``np.squeeze`` restores old behavior of objects that cannot handle an ``axis`` argument --------------------------------------------------------------------------------------- Prior to version ``1.7.0``, `numpy.squeeze` did not have an ``axis`` argument and all empty axes were removed by default. The incorporation of an ``axis`` argument made it possible to selectively squeeze single or multiple empty axes, but the old API expectation was not respected because axes could still be selectively removed (silent success) from an object expecting all empty axes to be removed. That silent, selective removal of empty axes for objects expecting the old behavior has been fixed and the old behavior restored. unstructured void array's ``.item`` method now returns a bytes object --------------------------------------------------------------------- ``.item`` now returns a ``bytes`` object instead of a buffer or byte array. This may affect code which assumed the return value was mutable, which is no longer the case. ``copy.copy`` and ``copy.deepcopy`` no longer turn ``masked`` into an array --------------------------------------------------------------------------- Since ``np.ma.masked`` is a readonly scalar, copying should be a no-op. These functions now behave consistently with ``np.copy()``. Multifield Indexing of Structured Arrays will still return a copy ----------------------------------------------------------------- The change that multi-field indexing of structured arrays returns a view instead of a copy is pushed back to 1.16. A new method ``numpy.lib.recfunctions.repack_fields`` has been introduced to help mitigate the effects of this change, which can be used to write code compatible with both numpy 1.15 and 1.16. For more information on how to update code to account for this future change see the "accessing multiple fields" section of the `user guide <https://docs.scipy.org/doc/numpy/user/basics.rec.html>`__. C API changes ============= New functions ``npy_get_floatstatus_barrier`` and ``npy_clear_floatstatus_barrier`` ----------------------------------------------------------------------------------- Functions ``npy_get_floatstatus_barrier`` and ``npy_clear_floatstatus_barrier`` have been added and should be used in place of the ``npy_get_floatstatus``and ``npy_clear_status`` functions. Optimizing compilers like GCC 8.1 and Clang were rearranging the order of operations when the previous functions were used in the ufunc SIMD functions, resulting in the floatstatus flags being checked before the operation whose status we wanted to check was run. See `10339 <https://github.com/numpy/numpy/issues/10370>`__. Changes to ``PyArray_GetDTypeTransferFunction`` ----------------------------------------------- ``PyArray_GetDTypeTransferFunction`` now defaults to using user-defined ``copyswapn`` / ``copyswap`` for user-defined dtypes. If this causes a significant performance hit, consider implementing ``copyswapn`` to reflect the implementation of ``PyArray_GetStridedCopyFn``. See `10898 <https://github.com/numpy/numpy/pull/10898>`__. New Features ============ ``np.gcd`` and ``np.lcm`` ufuncs added for integer and objects types -------------------------------------------------------------------- These compute the greatest common divisor, and lowest common multiple, respectively. These work on all the numpy integer types, as well as the builtin arbitrary-precision ``Decimal`` and ``long`` types. Support for cross-platform builds for iOS ----------------------------------------- The build system has been modified to add support for the ``_PYTHON_HOST_PLATFORM`` environment variable, used by ``distutils`` when compiling on one platform for another platform. This makes it possible to compile NumPy for iOS targets. This only enables you to compile NumPy for one specific platform at a time. Creating a full iOS-compatible NumPy package requires building for the 5 architectures supported by iOS (i386, x86_64, armv7, armv7s and arm64), and combining these 5 compiled builds products into a single "fat" binary. ``return_indices`` keyword added for ``np.intersect1d`` ------------------------------------------------------- New keyword ``return_indices`` returns the indices of the two input arrays that correspond to the common elements. ``np.quantile`` and ``np.nanquantile`` -------------------------------------- Like ``np.percentile`` and ``np.nanpercentile``, but takes quantiles in [0, 1] rather than percentiles in [0, 100]. ``np.percentile`` is now a thin wrapper around ``np.quantile`` with the extra step of dividing by 100. Build system ------------ Added experimental support for the 64-bit RISC-V architecture. Improvements ============ ``np.einsum`` updates --------------------- Syncs einsum path optimization tech between `numpy` and `opt_einsum`. In particular, the `greedy` path has received many enhancements by jcmgray. A full list of issues fixed are: * Arbitrary memory can be passed into the `greedy` path. Fixes gh-11210. * The greedy path has been updated to contain more dynamic programming ideas preventing a large number of duplicate (and expensive) calls that figure out the actual pair contraction that takes place. Now takes a few seconds on several hundred input tensors. Useful for matrix product state theories. * Reworks the broadcasting dot error catching found in gh-11218 gh-10352 to be a bit earlier in the process. * Enhances the `can_dot` functionality that previous missed an edge case (part of gh-11308). ``np.ufunc.reduce`` and related functions now accept an initial value --------------------------------------------------------------------- ``np.ufunc.reduce``, ``np.sum``, ``np.prod``, ``np.min`` and ``np.max`` all now accept an ``initial`` keyword argument that specifies the value to start the reduction with. ``np.flip`` can operate over multiple axes ------------------------------------------ ``np.flip`` now accepts None, or tuples of int, in its ``axis`` argument. If axis is None, it will flip over all the axes. ``histogram`` and ``histogramdd`` functions have moved to ``np.lib.histograms`` ------------------------------------------------------------------------------- These were originally found in ``np.lib.function_base``. They are still available under their un-scoped ``np.histogram(dd)`` names, and to maintain compatibility, aliased at ``np.lib.function_base.histogram(dd)``. Code that does ``from np.lib.function_base import *`` will need to be updated with the new location, and should consider not using ``import *`` in future. ``histogram`` will accept NaN values when explicit bins are given ----------------------------------------------------------------- Previously it would fail when trying to compute a finite range for the data. Since the range is ignored anyway when the bins are given explicitly, this error was needless. Note that calling ``histogram`` on NaN values continues to raise the ``RuntimeWarning`` s typical of working with nan values, which can be silenced as usual with ``errstate``. ``histogram`` works on datetime types, when explicit bin edges are given ------------------------------------------------------------------------ Dates, times, and timedeltas can now be histogrammed. The bin edges must be passed explicitly, and are not yet computed automatically. ``histogram`` "auto" estimator handles limited variance better -------------------------------------------------------------- No longer does an IQR of 0 result in ``n_bins=1``, rather the number of bins chosen is related to the data size in this situation. The edges retuned by `histogram`` and ``histogramdd`` now match the data float type ----------------------------------------------------------------------------------- When passed ``np.float16``, ``np.float32``, or ``np.longdouble`` data, the returned edges are now of the same dtype. Previously, ``histogram`` would only return the same type if explicit bins were given, and ``histogram`` would produce ``float64`` bins no matter what the inputs. ``histogramdd`` allows explicit ranges to be given in a subset of axes ---------------------------------------------------------------------- The ``range`` argument of `numpy.histogramdd` can now contain ``None`` values to indicate that the range for the corresponding axis should be computed from the data. Previously, this could not be specified on a per-axis basis. The normed arguments of ``histogramdd`` and ``histogram2d`` have been renamed ----------------------------------------------------------------------------- These arguments are now called ``density``, which is consistent with ``histogram``. The old argument continues to work, but the new name should be preferred. ``np.r_`` works with 0d arrays, and ``np.ma.mr_`` works with ``np.ma.masked`` ----------------------------------------------------------------------------- 0d arrays passed to the `r_` and `mr_` concatenation helpers are now treated as though they are arrays of length 1. Previously, passing these was an error. As a result, `numpy.ma.mr_` now works correctly on the ``masked`` constant. ``np.ptp`` accepts a ``keepdims`` argument, and extended axis tuples -------------------------------------------------------------------- ``np.ptp`` (peak-to-peak) can now work over multiple axes, just like ``np.max`` and ``np.min``. ``MaskedArray.astype`` now is identical to ``ndarray.astype`` ------------------------------------------------------------- This means it takes all the same arguments, making more code written for ndarray work for masked array too. Enable AVX2/AVX512 at compile time ---------------------------------- Change to simd.inc.src to allow use of AVX2 or AVX512 at compile time. Previously compilation for avx2 (or 512) with -march=native would still use the SSE code for the simd functions even when the rest of the code got AVX2. ``nan_to_num`` always returns scalars when receiving scalar or 0d inputs ------------------------------------------------------------------------ Previously an array was returned for integer scalar inputs, which is inconsistent with the behavior for float inputs, and that of ufuncs in general. For all types of scalar or 0d input, the result is now a scalar. ``np.flatnonzero`` works on numpy-convertible types --------------------------------------------------- ``np.flatnonzero`` now uses ``np.ravel(a)`` instead of ``a.ravel()``, so it works for lists, tuples, etc. ``np.interp`` returns numpy scalars rather than builtin scalars --------------------------------------------------------------- Previously ``np.interp(0.5, [0, 1], [10, 20])`` would return a ``float``, but now it returns a ``np.float64`` object, which more closely matches the behavior of other functions. Additionally, the special case of ``np.interp(object_array_0d, ...)`` is no longer supported, as ``np.interp(object_array_nd)`` was never supported anyway. As a result of this change, the ``period`` argument can now be used on 0d arrays. Allow dtype field names to be unicode in Python 2 ------------------------------------------------- Previously ``np.dtype([(u'name', float)])`` would raise a ``TypeError`` in Python 2, as only bytestrings were allowed in field names. Now any unicode string field names will be encoded with the ``ascii`` codec, raising a ``UnicodeEncodeError`` upon failure. This change makes it easier to write Python 2/3 compatible code using ``from __future__ import unicode_literals``, which previously would cause string literal field names to raise a TypeError in Python 2. Comparison ufuncs accept ``dtype=object``, overriding the default ``bool`` -------------------------------------------------------------------------- This allows object arrays of symbolic types, which override ``==`` and other operators to return expressions, to be compared elementwise with ``np.equal(a, b, dtype=object)``. ``sort`` functions accept ``kind='stable'`` ------------------------------------------- Up until now, to perform a stable sort on the data, the user must do: >>> np.sort([5, 2, 6, 2, 1], kind='mergesort') [1, 2, 2, 5, 6] because merge sort is the only stable sorting algorithm available in NumPy. However, having kind='mergesort' does not make it explicit that the user wants to perform a stable sort thus harming the readability. This change allows the user to specify kind='stable' thus clarifying the intent. Do not make temporary copies for in-place accumulation ------------------------------------------------------ When ufuncs perform accumulation they no longer make temporary copies because of the overlap between input an output, that is, the next element accumulated is added before the accumulated result is stored in its place, hence the overlap is safe. Avoiding the copy results in faster execution. ``linalg.matrix_power`` can now handle stacks of matrices --------------------------------------------------------- Like other functions in ``linalg``, ``matrix_power`` can now deal with arrays of dimension larger than 2, which are treated as stacks of matrices. As part of the change, to further improve consistency, the name of the first argument has been changed to ``a`` (from ``M``), and the exceptions for non-square matrices have been changed to ``LinAlgError`` (from ``ValueError``). Increased performance in ``random.permutation`` for multidimensional arrays --------------------------------------------------------------------------- ``permutation`` uses the fast path in ``random.shuffle`` for all input array dimensions. Previously the fast path was only used for 1-d arrays. Generalized ufuncs now accept ``axes``, ``axis`` and ``keepdims`` arguments --------------------------------------------------------------------------- One can control over which axes a generalized ufunc operates by passing in an ``axes`` argument, a list of tuples with indices of particular axes. For instance, for a signature of ``(i,j),(j,k)->(i,k)`` appropriate for matrix multiplication, the base elements are two-dimensional matrices and these are taken to be stored in the two last axes of each argument. The corresponding axes keyword would be ``[(-2, -1), (-2, -1), (-2, -1)]``. If one wanted to use leading dimensions instead, one would pass in ``[(0, 1), (0, 1), (0, 1)]``. For simplicity, for generalized ufuncs that operate on 1-dimensional arrays (vectors), a single integer is accepted instead of a single-element tuple, and for generalized ufuncs for which all outputs are scalars, the (empty) output tuples can be omitted. Hence, for a signature of ``(i),(i)->()`` appropriate for an inner product, one could pass in ``axes=[0, 0]`` to indicate that the vectors are stored in the first dimensions of the two inputs arguments. As a short-cut for generalized ufuncs that are similar to reductions, i.e., that act on a single, shared core dimension such as the inner product example above, one can pass an ``axis`` argument. This is equivalent to passing in ``axes`` with identical entries for all arguments with that core dimension (e.g., for the example above, ``axes=[(axis,), (axis,)]``). Furthermore, like for reductions, for generalized ufuncs that have inputs that all have the same number of core dimensions and outputs with no core dimension, one can pass in ``keepdims`` to leave a dimension with size 1 in the outputs, thus allowing proper broadcasting against the original inputs. The location of the extra dimension can be controlled with ``axes``. For instance, for the inner-product example, ``keepdims=True, axes=[-2, -2, -2]`` would act on the inner-product example, ``keepdims=True, axis=-2`` would act on the one-but-last dimension of the input arguments, and leave a size 1 dimension in that place in the output. float128 values now print correctly on ppc systems -------------------------------------------------- Previously printing float128 values was buggy on ppc, since the special double-double floating-point-format on these systems was not accounted for. float128s now print with correct rounding and uniqueness. Warning to ppc users: You should upgrade glibc if it is version <=2.23, especially if using float128. On ppc, glibc's malloc in these version often misaligns allocated memory which can crash numpy when using float128 values. New ``np.take_along_axis`` and ``np.put_along_axis`` functions -------------------------------------------------------------- When used on multidimensional arrays, ``argsort``, ``argmin``, ``argmax``, and ``argpartition`` return arrays that are difficult to use as indices. ``take_along_axis`` provides an easy way to use these indices to lookup values within an array, so that:: np.take_along_axis(a, np.argsort(a, axis=axis), axis=axis) is the same as:: np.sort(a, axis=axis) ``np.put_along_axis`` acts as the dual operation for writing to these indices within an array. ========================= ``` ### 1.14.6 ``` ========================== This is a bugfix release for bugs reported following the 1.14.5 release. The most significant fixes are: * Fix for behavior change in ``ma.masked_values(shrink=True)`` * Fix the new cached allocations machinery to be thread safe. The Python versions supported in this release are 2.7 and 3.4 - 3.7. The Python 3.6 wheels on PyPI should be compatible with all Python 3.6 versions. Contributors ============ A total of 4 people contributed to this release. People with a "+" by their names contributed a patch for the first time. * Charles Harris * Eric Wieser * Julian Taylor * Matti Picus Pull requests merged ==================== A total of 4 pull requests were merged for this release. * `11985 <https://github.com/numpy/numpy/pull/11985>`__: BUG: fix cached allocations without the GIL * `11986 <https://github.com/numpy/numpy/pull/11986>`__: BUG: Undo behavior change in ma.masked_values(shrink=True) * `11987 <https://github.com/numpy/numpy/pull/11987>`__: BUG: fix refcount leak in PyArray_AdaptFlexibleDType * `11995 <https://github.com/numpy/numpy/pull/11995>`__: TST: Add Python 3.7 testing to NumPy 1.14. ========================== ``` ### 1.14.5 ``` ========================== This is a bugfix release for bugs reported following the 1.14.4 release. The most significant fixes are: * fixes for compilation errors on alpine and NetBSD The Python versions supported in thi