NumPy是使用Python进行科学计算所需的基础软件包
NumPy是使用Python进行科学计算所需的基础软件包 charris released this
Assets
6
==========================
NumPy 1.16.0 Release Notes
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.53.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 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
andnumpy.core.sctypeNA
are
deprecated. They were buggy and not documented and will be removed in the
1.18 release. Usenumpy.sctypeDict
instead. 
The
numpy.asscalar
function is deprecated. It is an alias to the more
powerfulnumpy.ndarray.item
, not tested, and fails for scalars. 
The
numpy.set_array_ops
andnumpy.get_array_ops
functions are deprecated.
As part ofNEP 15
, they have been deprecated along with the CAPI functions
:c:func:PyArray_SetNumericOps
and :c:func:PyArray_GetNumericOps
. Users
who wish to override the inner loop functions in builtin ufuncs should use
:c:func:PyUFunc_ReplaceLoopBySignature
. 
The
numpy.unravel_index
keyword argumentdims
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 nonnumerical 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. Usenumpy.unique
instead. 
multifield 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
andnp.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 ("notatime") 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 Cstruct 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
4byte aligned instead of 8byte 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 Cstruct
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.
multifield 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.html#accessingmultiplefields>
__.
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 nonparametric method based on
crossvalidation.
.. _ISE: https://en.wikipedia.org/wiki/Histogram#Minimizing_crossvalidation_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
nocopy 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
outofband buffers, and with one less copy using inband 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 frontend 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 gh11525 for more
details.
Generalized ufunc signatures now allow fixedsize 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 twodimensional cartesian unit vector would be ()>(2)
; that
for one that converts two spherical angles to a threedimensional unit vector
would be (),()>(3)
; and that for the cross product of two
threedimensional 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 nonglibc
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 readonly 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 pathlike objects for more functions

The ``np.core.records.fromfile`` function now supports ``pathlib.Path``
and other pathlike objects in addition to a file object. Furthermore, the
``np.load`` function now also supports pathlike 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
* Nonrepresentable constructs raise exceptions, rather than producing
dangerously incorrect results:
* Bitfields are no longer interpreted as subarrays
* 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 nonnumerical 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 nonstandard factor in the scaling of the the
covariance matrix. Namely, rather than using the standard ``chisq/(MN)``, it
scaled it with ``chisq/(MN2)`` 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/(MN)``.
``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 cextension 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 cextension modules. They are now python
wrappers to the single `np.core/_multiarray_math` cextension module.
.. _`NEP 15` : http://www.numpy.org/neps/nep0015mergemultiarrayumath.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__``

It is now possible to override the implementation of almost all NumPy functions
on nonNumPy arrays by defining a ``__array_function__`` method, as described
in `NEP 18`_. The sole exception are functions for explicitly casting to NumPy
arrays such as ``np.array``. As noted in the NEP, this feature remains
experimental and the details of how to implement such overrides may change in
the future.
.. _`NEP 15` : http://www.numpy.org/neps/nep0015mergemultiarrayumath.html
.. _`NEP 18` : http://www.numpy.org/neps/nep0018arrayfunctionprotocol.html
Arrays based off readonly buffers cannot be set ``writeable``

We now disallow setting the ``writeable`` flag True on arrays created
from ``fromstring(readonlybuffer)``.
Checksums
=========
MD5

ab8191598ce94a21ad921e28c9271d25 numpy1.16.0rc2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
7ee0fc316d2880ec0b1e759e1c07b3d1 numpy1.16.0rc2cp27cp27mmanylinux1_i686.whl
e5cebb3ae393456320ddfa0253cdc95d numpy1.16.0rc2cp27cp27mmanylinux1_x86_64.whl
064af8e0490c2d28cd643100697a39df numpy1.16.0rc2cp27cp27mwin32.whl
a0863b121b467d305eb1d2064ef51512 numpy1.16.0rc2cp27cp27mwin_amd64.whl
a87ec16f1a05effdd1ba28bdc3c7061f numpy1.16.0rc2cp27cp27mumanylinux1_i686.whl
f6cfdf218925e1e28e7d3fdafe92a5b2 numpy1.16.0rc2cp27cp27mumanylinux1_x86_64.whl
95cecd379d9810a9380e6828d0f08406 numpy1.16.0rc2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
6db11880170de68b69d297cf7cbbef9f numpy1.16.0rc2cp35cp35mmanylinux1_i686.whl
33b4c48e61328b1f00f5a6b6c2e3cdee numpy1.16.0rc2cp35cp35mmanylinux1_x86_64.whl
d69ffcdac09f1b5ab7fa90b9b5be784a numpy1.16.0rc2cp35cp35mwin32.whl
10ed348dd993c333236471235c1104fa numpy1.16.0rc2cp35cp35mwin_amd64.whl
831fab17f94d61b7c8a210c5924a1016 numpy1.16.0rc2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
1a694634c2343513419c2c6fb26e32e7 numpy1.16.0rc2cp36cp36mmanylinux1_i686.whl
14c493bd03f43402d4eee9f35163ea9e numpy1.16.0rc2cp36cp36mmanylinux1_x86_64.whl
c60c44b5d088450abd2ce87742355b83 numpy1.16.0rc2cp36cp36mwin32.whl
ddfbf5509840ac28fbcff7082dede343 numpy1.16.0rc2cp36cp36mwin_amd64.whl
70cd6e4609d16e425d00f3f54863257e numpy1.16.0rc2cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a4dca83e6d5f55493795b6ebde455a27 numpy1.16.0rc2cp37cp37mmanylinux1_i686.whl
6e5c2094cb896f7ee55dcfbea80aba5a numpy1.16.0rc2cp37cp37mmanylinux1_x86_64.whl
e19330756e42a4d77b58c5c34fa58f4a numpy1.16.0rc2cp37cp37mwin32.whl
4b7ed9b7be41ce44e146af1d6bc0a4c4 numpy1.16.0rc2cp37cp37mwin_amd64.whl
4f06b36a9db7d61898bf0440ffb6b273 numpy1.16.0rc2.tar.gz
feb1ad51ad96a2b1f964f64bb34a671b numpy1.16.0rc2.zip
SHA256

9c60e0261aa35ebc671a9dd8e149bb03cdc5f928188c8f13249304ad94e01bfc numpy1.16.0rc2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2bd4ee471f85b315a8177826126660043a1529ff9d022d958182fa274268f86c numpy1.16.0rc2cp27cp27mmanylinux1_i686.whl
d82bcdab867ba5c3fb6a68c3970a7a01f556d8ab4466fdec78394a74be2f71c6 numpy1.16.0rc2cp27cp27mmanylinux1_x86_64.whl
2811b3e77d455c657f1d46c3d1e7f274e645cb3af44008b7dc02f6ca7cc1a106 numpy1.16.0rc2cp27cp27mwin32.whl
2d6e8376b9a12ff55e63aa805315c032a9669699a312badf36b1824258561f08 numpy1.16.0rc2cp27cp27mwin_amd64.whl
d164db66a4519186ec13f2917bd2fd229021e3f3a8c78a2eb34de2b3178e5329 numpy1.16.0rc2cp27cp27mumanylinux1_i686.whl
d4e305d720c5e7c247410d794da816998aab53103bf0b05bc94090a65537b89a numpy1.16.0rc2cp27cp27mumanylinux1_x86_64.whl
cc140dd5077f2d9051af585648d3b561bbb6fb48da6458424e8ec462aebd2ee2 numpy1.16.0rc2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0ad442c958da72443d3f35d29833aefad332f53601db19a24613f06a9731f131 numpy1.16.0rc2cp35cp35mmanylinux1_i686.whl
e05413b244108e41615697e26bdac211ca809054c027ccf59a96388b85ac2b00 numpy1.16.0rc2cp35cp35mmanylinux1_x86_64.whl
e75318498c0c5d5dc09f151bdadb8c8ac5762a236be328e33bbc0d079b349e7c numpy1.16.0rc2cp35cp35mwin32.whl
c4a023555dae1f0a1e411b67d1970cd168eff9526c0d11db47cb94d7b22948ec numpy1.16.0rc2cp35cp35mwin_amd64.whl
c064e12ebbc467baa2c3b0690b9296203d51c491546f1d13f796dc46c0dd4447 numpy1.16.0rc2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2b716b4084770af3055352377603a9eef3f6b557bb9ec621b1c96a18242ac6f9 numpy1.16.0rc2cp36cp36mmanylinux1_i686.whl
a0e1a7b003c8a2cd204d9e7530677f7b41afa90460d1cc1bb9f52cf559abe0ab numpy1.16.0rc2cp36cp36mmanylinux1_x86_64.whl
4037b8b94345c2803474171464b366cd6727e310673a070083c79cd3a880ae71 numpy1.16.0rc2cp36cp36mwin32.whl
96a0bb7951739868bffc4a2d4c27a7452c44a276f743140be8b48439bf8714a7 numpy1.16.0rc2cp36cp36mwin_amd64.whl
62686057967dfbc391aa8a0d9eeded12250636a06bd6b639e07d067bce1282b5 numpy1.16.0rc2cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
eef36d084b7f91256b5ce95665abfe24693622fcecd3af3cc4f96624c0d93981 numpy1.16.0rc2cp37cp37mmanylinux1_i686.whl
5d6cc7098b7911401a9350d51d009bfe359a6d272e191827a9c13ebc03fc2974 numpy1.16.0rc2cp37cp37mmanylinux1_x86_64.whl
9c168f97f9af48b78ababc79c74db7ce09219ac70e01dbd92683e0731f952a08 numpy1.16.0rc2cp37cp37mwin32.whl
43d2e7c25970570d8d0a9d85d4b6c4635a6b402e823c87c10fc37657621c2d9b numpy1.16.0rc2cp37cp37mwin_amd64.whl
f3863bdc042c30a176694a8e2a16c13f8e6894a349ba79e3fbbcfe7e895436b9 numpy1.16.0rc2.tar.gz
c264fbc5f17897e124368289f53980a04880d6ebdfd8b657884ff31154d23133 numpy1.16.0rc2.zip
charris released this
Assets
6
==========================
NumPy 1.16.0 Release Notes
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.53.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 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
andnumpy.core.sctypeNA
are
deprecated. They were buggy and not documented and will be removed in the
1.18 release. Usenumpy.sctypeDict
instead. 
The
numpy.asscalar
function is deprecated. It is an alias to the more
powerfulnumpy.ndarray.item
, not tested, and fails for scalars. 
The
numpy.set_array_ops
andnumpy.get_array_ops
functions are deprecated.
As part ofNEP 15
, they have been deprecated along with the CAPI functions
:c:func:PyArray_SetNumericOps
and :c:func:PyArray_GetNumericOps
. Users
who wish to override the inner loop functions in builtin ufuncs should use
:c:func:PyUFunc_ReplaceLoopBySignature
. 
The
numpy.unravel_index
keyword argumentdims
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 nonnumerical 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. Usenumpy.unique
instead. 
multifield 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
andnp.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 ("notatime") 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 Cstruct 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
4byte aligned instead of 8byte 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 Cstruct
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.
multifield 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.html#accessingmultiplefields>
__.
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 nonparametric method based on
crossvalidation.
.. _ISE: https://en.wikipedia.org/wiki/Histogram#Minimizing_crossvalidation_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
nocopy 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
outofband buffers, and with one less copy using inband 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 frontend 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 gh11525 for more
details.
Generalized ufunc signatures now allow fixedsize 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 twodimensional cartesian unit vector would be ()>(2)
; that
for one that converts two spherical angles to a threedimensional unit vector
would be (),()>(3)
; and that for the cross product of two
threedimensional 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 nonglibc
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 readonly 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 pathlike objects for more functions

The ``np.core.records.fromfile`` function now supports ``pathlib.Path``
and other pathlike objects in addition to a file object. Furthermore, the
``np.load`` function now also supports pathlike 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
* Nonrepresentable constructs raise exceptions, rather than producing
dangerously incorrect results:
* Bitfields are no longer interpreted as subarrays
* 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 nonnumerical 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 nonstandard factor in the scaling of the the
covariance matrix. Namely, rather than using the standard ``chisq/(MN)``, it
scaled it with ``chisq/(MN2)`` 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/(MN)``.
``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 cextension 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 cextension modules. They are now python
wrappers to the single `np.core/_multiarray_math` cextension module.
.. _`NEP 15` : http://www.numpy.org/neps/nep0015mergemultiarrayumath.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__``

It is now possible to override the implementation of almost all NumPy functions
on nonNumPy arrays by defining a ``__array_function__`` method, as described
in `NEP 18`_. The sole exception are functions for explicitly casting to NumPy
arrays such as ``np.array``. As noted in the NEP, this feature remains
experimental and the details of how to implement such overrides may change in
the future.
.. _`NEP 15` : http://www.numpy.org/neps/nep0015mergemultiarrayumath.html
.. _`NEP 18` : http://www.numpy.org/neps/nep0018arrayfunctionprotocol.html
Arrays based off readonly buffers cannot be set ``writeable``

We now disallow setting the ``writeable`` flag True on arrays created
from ``fromstring(readonlybuffer)``.
Checksums
=========
MD5

4cfd167c553c15cbffacad828e37fa1b numpy1.16.0rc1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
fc7acd76d8f2f5b69af7b14435ff6e5f numpy1.16.0rc1cp27cp27mmanylinux1_i686.whl
d3d05c0ade6bd5ed26c0d2f045cc2545 numpy1.16.0rc1cp27cp27mmanylinux1_x86_64.whl
78acdc2844f3711e670b5b0d6112fd46 numpy1.16.0rc1cp27cp27mwin32.whl
e24b99a1b2584e5c89a8bb25b755a229 numpy1.16.0rc1cp27cp27mwin_amd64.whl
28df62b2e4162a0be66a65b0405d2974 numpy1.16.0rc1cp27cp27mumanylinux1_i686.whl
443d09ffded8b4f52d4158e7e53d5e02 numpy1.16.0rc1cp27cp27mumanylinux1_x86_64.whl
4709d3b87b56e8d706baf998a746baa0 numpy1.16.0rc1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e3895e61d89db8219e01e263f342c91b numpy1.16.0rc1cp35cp35mmanylinux1_i686.whl
b0e7842ece6d07568341ec8c4e850466 numpy1.16.0rc1cp35cp35mmanylinux1_x86_64.whl
4f5de37348d5ab67661277a713e26317 numpy1.16.0rc1cp35cp35mwin32.whl
a629f86585a6a7f22afdcc953df543b5 numpy1.16.0rc1cp35cp35mwin_amd64.whl
69860375de9a74698322e9608d039e24 numpy1.16.0rc1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d75b3ec49d27915ea9ee0866a45b1606 numpy1.16.0rc1cp36cp36mmanylinux1_i686.whl
b103bc43115f9c5760e0f86de7191682 numpy1.16.0rc1cp36cp36mmanylinux1_x86_64.whl
b3c6cbd582b502b6069b9a85a4b52d3f numpy1.16.0rc1cp36cp36mwin32.whl
efde86e04767a20af7d7b671aa43a74e numpy1.16.0rc1cp36cp36mwin_amd64.whl
0da1b6b0fddea9eebcc6d06c161b109d numpy1.16.0rc1cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
439fefdac5de6e80c0213aa5dd3aed83 numpy1.16.0rc1cp37cp37mmanylinux1_i686.whl
a238bdbdaece30f8bdd68cb17b8fc0f3 numpy1.16.0rc1cp37cp37mmanylinux1_x86_64.whl
f27e4791cc0696451572350a64fc3509 numpy1.16.0rc1cp37cp37mwin32.whl
b90d6fefb38650b5a343171dfabe1e38 numpy1.16.0rc1cp37cp37mwin_amd64.whl
acfd5138cd9ba5a0ee434c112866e1d1 numpy1.16.0rc1.tar.gz
f9a9356b066174b1375d509d7fdf03a6 numpy1.16.0rc1.zip
SHA256

1d94a5649fb8412784d9edda539b266801ee87fc89b812ebf5ec0fdab96444a3 numpy1.16.0rc1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
f901fa2232562abf9250e4a86d2b50f008b2fe0f9d91bc1ca6a3ffd17c81d2a4 numpy1.16.0rc1cp27cp27mmanylinux1_i686.whl
4c725b6557eb043b963a8b4b5da560fec4500b5e2a9c4794adb408de838aeb94 numpy1.16.0rc1cp27cp27mmanylinux1_x86_64.whl
867ed40b1bebb50f8b060a1b2a76c227a436a7d9fc73bf873dbc8e79862a56af numpy1.16.0rc1cp27cp27mwin32.whl
70279fa434b878692c15bdb9b3376765ff63a91d5f1f6e5973eb34b0bddd7aa5 numpy1.16.0rc1cp27cp27mwin_amd64.whl
c5db80fc344977d3df5435ded1a8ce05719283aeacaaf60a818a4baf63c756e4 numpy1.16.0rc1cp27cp27mumanylinux1_i686.whl
026a3b7c46e01a736bdf27853ce2a4f56a4feb3147ff879dbd463ed4da0a511b numpy1.16.0rc1cp27cp27mumanylinux1_x86_64.whl
2a17337e1980e753d4bac3dd4859bc1300e995ddf05fc09828b8d60d932ce4d3 numpy1.16.0rc1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0efbe5f61044e7b0ed5583380aca26995c10cd625266f09b2d6ccef243499f2e numpy1.16.0rc1cp35cp35mmanylinux1_i686.whl
60dd924257899a44d55a7e548aba2a41c12e5d963b900ec138e0b15f3e6f3ef5 numpy1.16.0rc1cp35cp35mmanylinux1_x86_64.whl
078efe4fc53079acb4a70f378a1fbf97f22a1f864321788ae1fd9ca4c952bb10 numpy1.16.0rc1cp35cp35mwin32.whl
3dd416deba0e6b734e653961354ac2bee2888c832835304853b14299a8c3169a numpy1.16.0rc1cp35cp35mwin_amd64.whl
ff9859fffc4a03b196d742fe683684921e3d3819aa97d935b92d573b7ff0bf7b numpy1.16.0rc1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ad0a948011cafe20323944aea7570cea77c3659cf970ee4e94993a75fdf1bf3a numpy1.16.0rc1cp36cp36mmanylinux1_i686.whl
b53714c56ee9a1f1b46f7558ca1aa005704dba35334ff61288390be01b96b3b0 numpy1.16.0rc1cp36cp36mmanylinux1_x86_64.whl
e299aaed551f16c3822e261adc6d5685ad7067536ae6af00e53837b637dc1270 numpy1.16.0rc1cp36cp36mwin32.whl
9c76c0f114b729606081b0e4c49d2f7887946004872576f51b8bd50461f4110b numpy1.16.0rc1cp36cp36mwin_amd64.whl
bcf57e4694e32d7ebb9402cd3fcd9c4fd913a29f372fbefc8edd675a32262558 numpy1.16.0rc1cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c953969e4b9a65998be1d7e895613be77bd42d438b54f9ce8c2453616ca8f5c9 numpy1.16.0rc1cp37cp37mmanylinux1_i686.whl
09d327e93f2b13dfbfd6a7c2534441478896a24e9521f59f1ec64c775eff0066 numpy1.16.0rc1cp37cp37mmanylinux1_x86_64.whl
ff73c826d81442f00b38360e52618d94f811c8db9047546d135c0e56117f3812 numpy1.16.0rc1cp37cp37mwin32.whl
f735dad0d72598ca0e19f50a0891e83e496288038628addd86c05650fab49181 numpy1.16.0rc1cp37cp37mwin_amd64.whl
90aa92d9c1bf0cbde34c0eb3964b87d15f2a6de01da99af18615925e3b7d8a05 numpy1.16.0rc1.tar.gz
6e638a8d56af542aebf625efdacdfb555943c08044795ee7550789407f5b905c numpy1.16.0rc1.zip
charris released this
Assets
6
==========================
NumPy 1.15.4 Release Notes
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.43.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 32bit
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 32bit 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: BUG: Dealloc cached buffer info
 #12297: BUG: Fix fill value in masked array '==' and '!=' ops.
 #12307: DOC: Correct the default value of
optimize
innumpy.einsum
 #12320: REL: Prepare for the NumPy 1.15.4 release
Checksums
MD5
277c501cfcc67767d73d83a53ba69ecb numpy1.15.4cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
4c687d8cd7833e0b549d4a20905f29a2 numpy1.15.4cp27cp27mmanylinux1_i686.whl
988d0b321d0b7576b105528fc948ddc3 numpy1.15.4cp27cp27mmanylinux1_x86_64.whl
ea6bd39d05539847a0ebb12ff955251a numpy1.15.4cp27cp27mumanylinux1_i686.whl
8ef2d1ea4571cdd0e7e8dfd5128436b4 numpy1.15.4cp27cp27mumanylinux1_x86_64.whl
b550d4cc012623a0c38f1392e08f4805 numpy1.15.4cp27nonewin32.whl
cb38e4778d9db33199dc7bb6a69ce089 numpy1.15.4cp27nonewin_amd64.whl
fa0acf5b2f852454346df5486a4ff4d9 numpy1.15.4cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a7614f6318899aa1bfbc337232c4647f numpy1.15.4cp34cp34mmanylinux1_i686.whl
ae16e02274996ff926a30f23f6d6d7e8 numpy1.15.4cp34cp34mmanylinux1_x86_64.whl
c1e1f381de7abc96509d4c5463903755 numpy1.15.4cp34nonewin32.whl
c269c8f2fce6cefdffe5e3821fc04fb5 numpy1.15.4cp34nonewin_amd64.whl
8906282c374b9b008c5c6401e5dc750b numpy1.15.4cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
537949e404ecc5814cb0db534bdfef36 numpy1.15.4cp35cp35mmanylinux1_i686.whl
3b10a2fcf8610bbbfe08161e1d9d176e numpy1.15.4cp35cp35mmanylinux1_x86_64.whl
b67621a1c9b8dcac707ca22055629e9f numpy1.15.4cp35nonewin32.whl
25b45b69d624cb07a8c05a5f82779b0a numpy1.15.4cp35nonewin_amd64.whl
76ed46a4d4e9cdb7076bf1359d9df1d4 numpy1.15.4cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b98cbad7770856dc12c827dca7c201b4 numpy1.15.4cp36cp36mmanylinux1_i686.whl
6293fa6db83849aab3a8b1a606cf3d03 numpy1.15.4cp36cp36mmanylinux1_x86_64.whl
21df485f92248c13cab3838762d717f6 numpy1.15.4cp36nonewin32.whl
c9cf7a267f8d2f57dc6384cc8b9f5acf numpy1.15.4cp36nonewin_amd64.whl
1f6990e094c6b2bb47c6a528ac7b1263 numpy1.15.4cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e79239cd9a3ce3cbfa5e7345bfb2ca56 numpy1.15.4cp37cp37mmanylinux1_i686.whl
fc046ba978ef4dd0556af09643c57d30 numpy1.15.4cp37cp37mmanylinux1_x86_64.whl
6291159933eb5a7f9c0bf28ae9707739 numpy1.15.4cp37nonewin32.whl
6097910d675f9e81d5d131b91a6c5c61 numpy1.15.4cp37nonewin_amd64.whl
b3626fec2f39ab01cad8bbb63a103742 numpy1.15.4.tar.gz
219ac537d12cf06ed14f478662096ebc numpy1.15.4.zip
SHA256
18e84323cdb8de3325e741a7a8dd4a82db74fde363dce32b625324c7b32aa6d7 numpy1.15.4cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
154c35f195fd3e1fad2569930ca51907057ae35e03938f89a8aedae91dd1b7c7 numpy1.15.4cp27cp27mmanylinux1_i686.whl
4d8d3e5aa6087490912c14a3c10fbdd380b40b421c13920ff468163bc50e016f numpy1.15.4cp27cp27mmanylinux1_x86_64.whl
c857ae5dba375ea26a6228f98c195fec0898a0fd91bcf0e8a0cae6d9faf3eca7 numpy1.15.4cp27cp27mumanylinux1_i686.whl
0df89ca13c25eaa1621a3f09af4c8ba20da849692dcae184cb55e80952c453fb numpy1.15.4cp27cp27mumanylinux1_x86_64.whl
36e36b6868e4440760d4b9b44587ea1dc1f06532858d10abba98e851e154ca70 numpy1.15.4cp27nonewin32.whl
99d59e0bcadac4aa3280616591fb7bcd560e2218f5e31d5223a2e12a1425d495 numpy1.15.4cp27nonewin_amd64.whl
edfa6fba9157e0e3be0f40168eb142511012683ac3dc82420bee4a3f3981b30e numpy1.15.4cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b261e0cb0d6faa8fd6863af26d30351fd2ffdb15b82e51e81e96b9e9e2e7ba16 numpy1.15.4cp34cp34mmanylinux1_i686.whl
db9814ff0457b46f2e1d494c1efa4111ca089e08c8b983635ebffb9c1573361f numpy1.15.4cp34cp34mmanylinux1_x86_64.whl
df04f4bad8a359daa2ff74f8108ea051670cafbca533bb2636c58b16e962989e numpy1.15.4cp34nonewin32.whl
7da99445fd890206bfcc7419f79871ba8e73d9d9e6b82fe09980bc5bb4efc35f numpy1.15.4cp34nonewin_amd64.whl
56994e14b386b5c0a9b875a76d22d707b315fa037affc7819cda08b6d0489756 numpy1.15.4cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ecf81720934a0e18526177e645cbd6a8a21bb0ddc887ff9738de07a1df5c6b61 numpy1.15.4cp35cp35mmanylinux1_i686.whl
cf5bb4a7d53a71bb6a0144d31df784a973b36d8687d615ef6a7e9b1809917a9b numpy1.15.4cp35cp35mmanylinux1_x86_64.whl
561ef098c50f91fbac2cc9305b68c915e9eb915a74d9038ecf8af274d748f76f numpy1.15.4cp35nonewin32.whl
4f41fd159fba1245e1958a99d349df49c616b133636e0cf668f169bce2aeac2d numpy1.15.4cp35nonewin_amd64.whl
416a2070acf3a2b5d586f9a6507bb97e33574df5bd7508ea970bbf4fc563fa52 numpy1.15.4cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
24fd645a5e5d224aa6e39d93e4a722fafa9160154f296fd5ef9580191c755053 numpy1.15.4cp36cp36mmanylinux1_i686.whl
23557bdbca3ccbde3abaa12a6e82299bc92d2b9139011f8c16ca1bb8c75d1e95 numpy1.15.4cp36cp36mmanylinux1_x86_64.whl
b1853df739b32fa913cc59ad9137caa9cc3d97ff871e2bbd89c2a2a1d4a69451 numpy1.15.4cp36nonewin32.whl
73a1f2a529604c50c262179fcca59c87a05ff4614fe8a15c186934d84d09d9a5 numpy1.15.4cp36nonewin_amd64.whl
1e8956c37fc138d65ded2d96ab3949bd49038cc6e8a4494b1515b0ba88c91565 numpy1.15.4cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a4cc09489843c70b22e8373ca3dfa52b3fab778b57cf81462f1203b0852e95e3 numpy1.15.4cp37cp37mmanylinux1_i686.whl
4a22dc3f5221a644dfe4a63bf990052cc674ef12a157b1056969079985c92816 numpy1.15.4cp37cp37mmanylinux1_x86_64.whl
b1f44c335532c0581b77491b7715a871d0dd72e97487ac0f57337ccf3ab3469b numpy1.15.4cp37nonewin32.whl
a61dc29cfca9831a03442a21d4b5fd77e3067beca4b5f81f1a89a04a71cf93fa numpy1.15.4cp37nonewin_amd64.whl
766e09248298e3ad4ae4a805159f358610bbe7dcc7b4a14e5df2128c05655b80 numpy1.15.4.tar.gz
3d734559db35aa3697dadcea492a423118c5c55d176da2f3be9c98d4803fc2a7 numpy1.15.4.zip
charris released this
Assets
6
==========================
NumPy 1.15.3 Release Notes
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.43.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 32bit
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 32bit 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: MAINT: Blacklist some MSVC complex functions.
 #12083: TST: Add azure CI testing to 1.15.x branch.
 #12084: BUG: test_path() now uses Path.resolve()
 #12085: TST, MAINT: Fix some failing tests on azurepipelines mac and...
 #12187: BUG: Fix memory leak in mapping.c
 #12188: BUG: Allow boolean subtract in histogram
 #12189: BUG: Fix inplace permutation
 #12190: BUG: limit default for get_num_build_jobs() to 8
 #12191: BUG: OBJECT_to_* should check for errors
 #12192: DOC: Prepare for NumPy 1.15.3 release.
 #12237: BUG: Fix MaskedArray fill_value type conversion.
 #12238: TST: Backport azurepipeline testing fixes for Mac
Checksums
MD5
fc1ae8356a65804d02e5c7d9c1c07f65 numpy1.15.3cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
85faf750ff68d76dad812eb6410cc417 numpy1.15.3cp27cp27mmanylinux1_i686.whl
6d92d50f6235501475b642fc35212ad7 numpy1.15.3cp27cp27mmanylinux1_x86_64.whl
f7430f4ca8d179a9e34072c0d1c1ca9c numpy1.15.3cp27cp27mumanylinux1_i686.whl
ebd394af280ee41b55add821f84dc180 numpy1.15.3cp27cp27mumanylinux1_x86_64.whl
3bac2fd14dc19c20a0ced77bb8c395de numpy1.15.3cp27nonewin32.whl
da69a44d0292379a261f1bf33b2afe3e numpy1.15.3cp27nonewin_amd64.whl
c021f69eeed541202947d11c0ec3c2f4 numpy1.15.3cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
4c2a4a7685c7431937aa0b5e6425b7de numpy1.15.3cp34cp34mmanylinux1_i686.whl
2eb4e845844b91853743bb4d4316e237 numpy1.15.3cp34cp34mmanylinux1_x86_64.whl
47b03a3e34152c7e1ae7056f672674a5 numpy1.15.3cp34nonewin32.whl
64ebc4e0a722e5a6f1bd697309c3f951 numpy1.15.3cp34nonewin_amd64.whl
f7a9b021b45372fa39e009ae396d6108 numpy1.15.3cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
7a7578978757cb69507ab680a2f9b8f3 numpy1.15.3cp35cp35mmanylinux1_i686.whl
52d5bd16e06561e735cb7f461370e697 numpy1.15.3cp35cp35mmanylinux1_x86_64.whl
c1421e59a425b6cd1307a45612c4911f numpy1.15.3cp35nonewin32.whl
2ea2c18feb7f92ebd6b64261265d1b7f numpy1.15.3cp35nonewin_amd64.whl
ed7b1d79ad554f59c65b6c2d15924624 numpy1.15.3cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
bece3ef7768bfa7b354b8d1014aa85b3 numpy1.15.3cp36cp36mmanylinux1_i686.whl
4ed669d22449b6e1759b320ff9b37eb7 numpy1.15.3cp36cp36mmanylinux1_x86_64.whl
a3c7ce17e1fdf009950f2f41adcde29b numpy1.15.3cp36nonewin32.whl
890f23c488a00a2c64578bcb3737533e numpy1.15.3cp36nonewin_amd64.whl
c3a332b97d53c60d8c129a1a8e062652 numpy1.15.3cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
096f70a3a147a596a9317ce8ac9bf1bd numpy1.15.3cp37cp37mmanylinux1_i686.whl
2317122b49e79ffad91250a428ca54f9 numpy1.15.3cp37cp37mmanylinux1_x86_64.whl
2719106f42758fd285bce25fa3c1a78e numpy1.15.3cp37nonewin32.whl
9a692a2bbcbaabf98f19fbd9c0c5c163 numpy1.15.3cp37nonewin_amd64.whl
274dd6db3a13c6b6c47a05b5365e1749 numpy1.15.3.tar.gz
7f1b9e521c2a662cecf3708026e8bdad numpy1.15.3.zip
SHA256
3c7959f750b54b445f14962a3ddc41b9eadbab00b86da55fbb1967b2b79aad10 numpy1.15.3cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
9d1598573d310104acb90377f0a8c2319f737084689f5eb18012becaf345cda5 numpy1.15.3cp27cp27mmanylinux1_i686.whl
a988db28f54e104a01e8573ceb6f28202b4c15635b1450b2e3b2b822c6564f9b numpy1.15.3cp27cp27mmanylinux1_x86_64.whl
3d8f9273c763a139a99e65c2a3c10f1109df30bedae7f011b10d95c538364704 numpy1.15.3cp27cp27mumanylinux1_i686.whl
919f65e0732195474897b1cafefb4d4e7c2bb8174a725e506b62e9096e4df28d numpy1.15.3cp27cp27mumanylinux1_x86_64.whl
d263f8f14f2da0c079c0297e829e550d8f2c4e0ffef215506bd1d0ddd2bff3de numpy1.15.3cp27nonewin32.whl
b12fe6f31babb9477aa0f9692730654b3ee0e71f33b4568170dfafd439caf0a2 numpy1.15.3cp27nonewin_amd64.whl
febd31cd0d2fd2509ca2ec53cb339f8bf593c1bd245b9fc55c1917a68532a0af numpy1.15.3cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d0f36a24cf8061a2c03e151be3418146717505b9b4ec17502fa3bbdb04ec1431 numpy1.15.3cp34cp34mmanylinux1_i686.whl
63bca71691339d2d6f8a7c970821f2b12098a53afccc0190d4e1555e75e5223a numpy1.15.3cp34cp34mmanylinux1_x86_64.whl
b7599ff4acd23f5de983e3aec772153b1043e131487a5c6ad0f94b41a828877a numpy1.15.3cp34nonewin32.whl
c9f4dafd6065c4c782be84cd67ceeb9b1d4380af60a7af32be10ebecd723385e numpy1.15.3cp34nonewin_amd64.whl
32a07241cb624e104b88b08dea2851bf4ec5d65a1f599d7735041ced7171fd7a numpy1.15.3cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
8bc4b92a273659e44ca3f3a2f8786cfa39d8302223bcfe7df794429c63d5f5a1 numpy1.15.3cp35cp35mmanylinux1_i686.whl
2f5ebc7a04885c7d69e5daa05208faef4db7f1ae6a99f4d36962df8cd54cdc76 numpy1.15.3cp35cp35mmanylinux1_x86_64.whl
ce3622b73ccd844ba301c1aea65d36cf9d8331e7c25c16b1725d0f14db99aaf4 numpy1.15.3cp35nonewin32.whl
9fff90c88bfaad2901be50453d5cd7897a826c1d901f0654ee1d73ab3a48cd18 numpy1.15.3cp35nonewin_amd64.whl
032df9b6571c5f1d41ea6f6a189223208cb488990373aa686aca55570fcccb42 numpy1.15.3cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
866a7c8774ccc7d603667fad95456b4cf56d79a2bb5a7648ac9f0082e0b9416e numpy1.15.3cp36cp36mmanylinux1_i686.whl
7ae9c3baff3b989859c88e0168ad10902118595b996bf781eaf011bb72428798 numpy1.15.3cp36cp36mmanylinux1_x86_64.whl
d8837ff272800668aabdfe70b966631914b0d6513aed4fc1b1428446f771834d numpy1.15.3cp36nonewin32.whl
fa337b6bd5fe2b8c4e705f4102186feb9985de9bb8536d32d5129a658f1789e0 numpy1.15.3cp36nonewin_amd64.whl
2aa0910eaeb603b1a5598193cc3bc8eacf1baf6c95cbc3955eb8e15fa380c133 numpy1.15.3cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ef694fe72a3995aa778a5095bda946e0d31f7efabd5e8063ad8c6238ab7d3f78 numpy1.15.3cp37cp37mmanylinux1_i686.whl
f1fd1a6f40a501ba4035f5ed2c1f4faa68245d1407bf97d2ee401e4f23d1720b numpy1.15.3cp37cp37mmanylinux1_x86_64.whl
094f8a83e5bd0a44a7557fa24a46db6ba7d5299c389ddbc9e0e18722f567fb63 numpy1.15.3cp37nonewin32.whl
a245464ddf6d90e2d6287e9cef6bcfda2a99467fdcf1b677b99cd0b6c7b43de2 numpy1.15.3cp37nonewin_amd64.whl
4656ea0d66a3724fd88aafa39a0c5cef216d1257a71b40534fe589abd46ba77b numpy1.15.3.tar.gz
1c0c80e74759fa4942298044274f2c11b08c86230b25b8b819e55e644f5ff2b6 numpy1.15.3.zip
v1.15.0
charris released this
Assets
==========================
NumPy 1.15.0 Release Notes
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.43.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
andnumpy.lcm
, to compute the greatest common divisor and least
common multiple. 
numpy.ma.stack
, thenumpy.stack
arrayjoining function generalized to
masked arrays. 
numpy.quantile
function, an interface topercentile
without factors of
100 
numpy.nanquantile
function, an interface tonanpercentile
without
factors of 100 
numpy.printoptions
, a context manager that sets print options temporarily
for the scope of thewith
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
andnpy_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
unaliasedpickle.<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 inind = [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 asarr[[[0, 1], [0, 1]]]
, currently interpreted as
arr[array([0, 1]), array([0, 1])]
, that will be interpreted
asarr[array([[0, 1], [0, 1]])]
in the future. 
Imports from the following submodules 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 builtin Pythonsum
instead. 
Users of the CAPI should call
PyArrayResolveWriteBackIfCopy
or
PyArray_DiscardWritbackIfCopy
on any array with theWRITEBACKIFCOPY
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 callit.close()
. A
RuntimeWarning
may be emitted otherwise in these cases. 
The
normed
argument ofnp.histogram
, deprecated long ago in 1.6.0,
now emits aDeprecationWarning
.
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 errorprone 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 monkeypatches 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 noop. These
functions now behave consistently with np.copy()
.
Multifield Indexing of Structured Arrays will still return a copy
The change that multifield 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 userdefined
copyswapn
/ copyswap
for userdefined 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>
__.
 Functions
npy_get_floatstatus_barrier
andnpy_clear_floatstatus_barrier
have been added and should be used in place of thenpy_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>
__.
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 arbitraryprecision Decimal
and long
types.
Support for crossplatform 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 iOScompatible 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 64bit RISCV 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 gh11210.  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 gh11218 gh10352 to be
a bit earlier in the process.  Enhances the
can_dot
functionality that previous missed an edge case (part
of gh11308).
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 unscoped 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 `histogramand
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 peraxis 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
(peaktopeak) 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 numpyconvertible 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 inplace 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 nonsquare
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 1d 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 twodimensional 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 1dimensional arrays
(vectors), a single integer is accepted instead of a singleelement 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 shortcut 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
innerproduct example, keepdims=True, axes=[2, 2, 2]
would act on the
innerproduct example, keepdims=True, axis=2
would act on the
onebutlast 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
doubledouble floatingpointformat 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.
Checksums
MD5
4957a50c1125fdecb4cb51829f5feba1 numpy1.15.0cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d5ffa73c6a3eeba8cfcab283e7db3c2f numpy1.15.0cp27cp27mmanylinux1_i686.whl
a6f7aa33d4d1598dc33831a4bb36570d numpy1.15.0cp27cp27mmanylinux1_x86_64.whl
cbdd2291782deb29f41c9b7d121264e0 numpy1.15.0cp27cp27mumanylinux1_i686.whl
0bd79da73435161850099bfcacc75fae numpy1.15.0cp27cp27mumanylinux1_x86_64.whl
73f930c046ac09e518d0b4cf2f8ff642 numpy1.15.0cp27nonewin32.whl
7ba5b463728a792dced42fd6259e511f numpy1.15.0cp27nonewin_amd64.whl
badfc9f713510d59f478037c88b3d963 numpy1.15.0cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
662f2536cac7b841f86e9b7488e52371 numpy1.15.0cp34cp34mmanylinux1_i686.whl
346d9239f7f12bb7042f8bc847928dc1 numpy1.15.0cp34cp34mmanylinux1_x86_64.whl
fd03012584359cd05cee08408df5897d numpy1.15.0cp34nonewin32.whl
1032db03cefd82e87f72f2b04b15b7ae numpy1.15.0cp34nonewin_amd64.whl
cc463ee62af94c8410fdf95ce9933c3c numpy1.15.0cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
77655199a4e18719dd5a0b348c44fc92 numpy1.15.0cp35cp35mmanylinux1_i686.whl
d76c54272549cf3a2165d40d3fea5e30 numpy1.15.0cp35cp35mmanylinux1_x86_64.whl
956c6f7c216b677b27628a97150cd069 numpy1.15.0cp35nonewin32.whl
2ab8080576932775167a6f9c772b91e4 numpy1.15.0cp35nonewin_amd64.whl
1a01c8d089d488565acc2836d03a7482 numpy1.15.0cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
5606fa1c1e13e789b802102699d613e2 numpy1.15.0cp36cp36mmanylinux1_i686.whl
5635343a70f7cdd17f372966db1526d3 numpy1.15.0cp36cp36mmanylinux1_x86_64.whl
166e901c1a86da5ffb8c6d3090ed917e numpy1.15.0cp36nonewin32.whl
6423497ad5a610c1deed606ce44893bd numpy1.15.0cp36nonewin_amd64.whl
e232fbba29585812bf7fa547f671b768 numpy1.15.0cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b2fc4551651fae84eb01b8a37f2e1e69 numpy1.15.0cp37cp37mmanylinux1_i686.whl
36ed60bef7c5cb252b9d0e8dc5029e08 numpy1.15.0cp37cp37mmanylinux1_x86_64.whl
4482a89fa4540c8bbf76028621931266 numpy1.15.0cp37nonewin32.whl
cfef18ee246468752f1686147c70bd0a numpy1.15.0cp37nonewin_amd64.whl
5cf4daff88042326334266f80ad38884 numpy1.15.0.tar.gz
20e13185089011116a98e11c9bf8aa07 numpy1.15.0.zip
SHA256
a17a8fd5df4fec5b56b4d11c9ba8b9ebfb883c90ec361628d07be00aaa4f009a numpy1.15.0cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c3ac359ace241707e5a48fe2922e566ac666aacacf4f8031f2994ac429c31344 numpy1.15.0cp27cp27mmanylinux1_i686.whl
e2317cf091c2e7f0dacdc2e72c693cc34403ca1f8e3807622d0bb653dc978616 numpy1.15.0cp27cp27mmanylinux1_x86_64.whl
64c6acf5175745fd1b7b7e17c74fdbfb7191af3b378bc54f44560279f41238d3 numpy1.15.0cp27cp27mumanylinux1_i686.whl
924f37e66db78464b4b85ed4b6d2e5cda0c0416e657cac7ccbef14b9fa2c40b5 numpy1.15.0cp27cp27mumanylinux1_x86_64.whl
674ea7917f0657ddb6976bd102ac341bc493d072c32a59b98e5b8c6eaa2d5ec0 numpy1.15.0cp27nonewin32.whl
ae3864816287d0e86ead580b69921daec568fe680857f07ee2a87bf7fd77ce24 numpy1.15.0cp27nonewin_amd64.whl
78c35dc7ad184aebf3714dbf43f054714c6e430e14b9c06c49a864fb9e262030 numpy1.15.0cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c7c660cc0209fdf29a4e50146ca9ac9d8664acaded6b6ae2f5d0ae2e91a0f0cd numpy1.15.0cp34cp34mmanylinux1_i686.whl
3fbccb399fe9095b1c1d7b41e7c7867db8aa0d2347fc44c87a7a180cedda112b numpy1.15.0cp34cp34mmanylinux1_x86_64.whl
aaa519335a71f87217ca8a680c3b66b61960e148407bdf5c209c42f50fe30f49 numpy1.15.0cp34nonewin32.whl
62cb836506f40ce2529bfba9d09edc4b2687dd18c56cf4457e51c3e7145402fd numpy1.15.0cp34nonewin_amd64.whl
55daf757e5f69aa75b4477cf4511bf1f96325c730e4ad32d954ccb593acd2585 numpy1.15.0cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b5f8c15cb9173f6cdf0f994955e58d1265331029ae26296232379461a297e5f2 numpy1.15.0cp35cp35mmanylinux1_i686.whl
24f3bb9a5f6c3936a8ccd4ddfc1210d9511f4aeb879a12efd2e80bec647b8695 numpy1.15.0cp35cp35mmanylinux1_x86_64.whl
34033b581bc01b1135ca2e3e93a94daea7c739f21a97a75cca93e29d9f0c8e71 numpy1.15.0cp35nonewin32.whl
f5a758252502b466b9c2b201ea397dae5a914336c987f3a76c3741a82d43c96e numpy1.15.0cp35nonewin_amd64.whl
14fb76bde161c87dcec52d91c78f65aa8a23aa2e1530a71f412dabe03927d917 numpy1.15.0cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
816645178f2180be257a576b735d3ae245b1982280b97ae819550ce8bcdf2b6b numpy1.15.0cp36cp36mmanylinux1_i686.whl
f2a778dd9bb3e4590dbe3bbac28e7c7134280c4ec97e3bf8678170ee58c67b21 numpy1.15.0cp36cp36mmanylinux1_x86_64.whl
7f17efe9605444fcbfd990ba9b03371552d65a3c259fc2d258c24fb95afdd728 numpy1.15.0cp36nonewin32.whl
73a816e441dace289302e04a7a34ec4772ed234ab6885c968e3ca2fc2d06fe2d numpy1.15.0cp36nonewin_amd64.whl
21041014b7529237994a6b578701c585703fbb3b1bea356cdb12a5ea7804241c numpy1.15.0cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d690a2ff49f6c3bc35336693c9924fe5916be3cc0503fe1ea6c7e2bf951409ee numpy1.15.0cp37cp37mmanylinux1_i686.whl
50718eea8e77a1bedcc85befd22c8dbf5a24c9d2c0c1e36bbb8d7a38da847eb3 numpy1.15.0cp37cp37mmanylinux1_x86_64.whl
fb4c33a404d9eff49a0cdc8ead0af6453f62f19e071b60d283f9dc05581e4134 numpy1.15.0cp37nonewin32.whl
61efc65f325770bbe787f34e00607bc124f08e6c25fdf04723848585e81560dc numpy1.15.0cp37nonewin_amd64.whl
259934a941663e93fdd5d28ce3f6aa2a81ce7dda85c395dd07b1f1edff2e0236 numpy1.15.0.tar.gz
f28e73cf18d37a413f7d5de35d024e6b98f14566a10d82100f9dc491a7d449f9 numpy1.15.0.zip
v1.15.0rc2
charris released this
Assets
==========================
NumPy 1.15.0 Release Notes
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.43.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
andnumpy.lcm
, to compute the greatest common divisor and least
common multiple. 
numpy.ma.stack
, thenumpy.stack
arrayjoining function generalized to
masked arrays. 
numpy.quantile
function, an interface topercentile
without factors of
100 
numpy.nanquantile
function, an interface tonanpercentile
without
factors of 100 
numpy.printoptions
, a context manager that sets print options temporarily
for the scope of thewith
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
andnpy_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
unaliasedpickle.<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 inind = [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 asarr[[[0, 1], [0, 1]]]
, currently interpreted as
arr[array([0, 1]), array([0, 1])]
, that will be interpreted
asarr[array([[0, 1], [0, 1]])]
in the future. 
Imports from the following submodules 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 builtin Pythonsum
instead. 
Users of the CAPI should call
PyArrayResolveWriteBackIfCopy
or
PyArray_DiscardWritbackIfCopy
on any array with theWRITEBACKIFCOPY
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 callit.close()
. A
RuntimeWarning
may be emitted otherwise in these cases. 
The
normed
argument ofnp.histogram
, deprecated long ago in 1.6.0,
now emits aDeprecationWarning
.
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 errorprone 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 monkeypatches 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 noop. These
functions now behave consistently with np.copy()
.
Multifield Indexing of Structured Arrays will still return a copy
The change that multifield 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 userdefined
copyswapn
/ copyswap
for userdefined 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>
__.
 Functions
npy_get_floatstatus_barrier
andnpy_clear_floatstatus_barrier
have been added and should be used in place of thenpy_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>
__.
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 arbitraryprecision Decimal
and long
types.
Support for crossplatform 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 iOScompatible 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 64bit RISCV 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 gh11210.  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 gh11218 gh10352 to be
a bit earlier in the process.  Enhances the
can_dot
functionality that previous missed an edge case (part
of gh11308).
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 unscoped 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 `histogramand
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 peraxis 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
(peaktopeak) 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 numpyconvertible 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 inplace 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 nonsquare
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 1d 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 twodimensional 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 1dimensional arrays
(vectors), a single integer is accepted instead of a singleelement 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 shortcut 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
innerproduct example, keepdims=True, axes=[2, 2, 2]
would act on the
innerproduct example, keepdims=True, axis=2
would act on the
onebutlast 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
doubledouble floatingpointformat 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.
Checksums
MD5
8316260e8887fc8bcf5f0b05f63c5019 numpy1.15.0rc2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2891ad8dbc338eba71726d460542a081 numpy1.15.0rc2cp27cp27mmanylinux1_i686.whl
6d222985f3f97c5e2fc1153eb8373808 numpy1.15.0rc2cp27cp27mmanylinux1_x86_64.whl
a07824b238cfb6a28997802e5196b59a numpy1.15.0rc2cp27cp27mumanylinux1_i686.whl
bdcdf5b7af86c3c9e7986443f958088a numpy1.15.0rc2cp27cp27mumanylinux1_x86_64.whl
03402a54a4160992470418bb2d8b80ce numpy1.15.0rc2cp27nonewin32.whl
8d43fa19d44eb1984103a3d6a36ca1d8 numpy1.15.0rc2cp27nonewin_amd64.whl
584955fb44be27fdeb98403fc7377570 numpy1.15.0rc2cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
85f2e7d543d164fbd3fd8eaebc8e37b0 numpy1.15.0rc2cp34cp34mmanylinux1_i686.whl
305290d750a6d3d6b0730faac3bdd918 numpy1.15.0rc2cp34cp34mmanylinux1_x86_64.whl
ca67388f3ab2de181caaf35b219e4bb0 numpy1.15.0rc2cp34nonewin32.whl
112a63e88d58a841e286015f213246e5 numpy1.15.0rc2cp34nonewin_amd64.whl
fd8aa9b7261e96694546956f6580e930 numpy1.15.0rc2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a95d9721714724c129a804d37e226b8c numpy1.15.0rc2cp35cp35mmanylinux1_i686.whl
199229506044c8d47b8dba19a093c7a6 numpy1.15.0rc2cp35cp35mmanylinux1_x86_64.whl
cd560aae25afd852181a9f89c82eecac numpy1.15.0rc2cp35nonewin32.whl
981140d5b42ad1457ddff565576073a3 numpy1.15.0rc2cp35nonewin_amd64.whl
1b83a71e5021a582d9f77427394c36e1 numpy1.15.0rc2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
791f0204b92772284472af1769ecbcba numpy1.15.0rc2cp36cp36mmanylinux1_i686.whl
24679506658bee564e9c4c96de5cffaf numpy1.15.0rc2cp36cp36mmanylinux1_x86_64.whl
daeb5f3144795c51039f79fdf15da10d numpy1.15.0rc2cp36nonewin32.whl
8a32e40e2d2a82bb86a2887fe7b72120 numpy1.15.0rc2cp36nonewin_amd64.whl
a6856a9ee8e6faae5d6d7424029d5390 numpy1.15.0rc2cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
566a8a2fd66be5fec607254abdc001be numpy1.15.0rc2cp37cp37mmanylinux1_i686.whl
ed94c261b602b88fabd9de497adfe461 numpy1.15.0rc2cp37cp37mmanylinux1_x86_64.whl
6045f7e99b4e29ec5e5255aafafa9546 numpy1.15.0rc2cp37nonewin32.whl
d0cafbac87ba71cea7b3617931f1a71e numpy1.15.0rc2cp37nonewin_amd64.whl
c2e3c18e470506059b44e50d5153609a numpy1.15.0rc2.tar.gz
1709c599dcc04f37316df85df451b3d9 numpy1.15.0rc2.zip
SHA256
5e4f9a3ea77cfeae16e1227ddd887c33b24dcc38e90add9630d71bd3ad96c13a numpy1.15.0rc2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
8d1f49ea7f50aeddbe5bead5af75aba20e15237908aedc6f35e3cd8548372783 numpy1.15.0rc2cp27cp27mmanylinux1_i686.whl
28cb017a0502e46d27a1f4af25c199e4609e3193c1f39b24b4a677d7a737f477 numpy1.15.0rc2cp27cp27mmanylinux1_x86_64.whl
8c02ccade177d82a366dba221eb6fcc85f63c3147817526883084c8b50aba471 numpy1.15.0rc2cp27cp27mumanylinux1_i686.whl
bc2073c9a97821b8bbf8cc58a3480aaf5897ee3c812427410aa03bd0615ed24e numpy1.15.0rc2cp27cp27mumanylinux1_x86_64.whl
316122b90b48dc7cd93232b8d0e6b82d73ef34e18f96d9c4d49f7be3f2b86759 numpy1.15.0rc2cp27nonewin32.whl
e2c57051f9126291b82043aefd01aa3f3523a7db27f20f6e0959e02983ee601f numpy1.15.0rc2cp27nonewin_amd64.whl
04847c434f6a9dce1785f4f6adf6d15d057677ec86ad7139e089f505040fc02f numpy1.15.0rc2cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
714b87ffc1cb76eb658898f0105cfec673615458b472f0c838a69d1de28ddaaf numpy1.15.0rc2cp34cp34mmanylinux1_i686.whl
8ddb2abf160e25b1c0a0dd648c686332c33d52df88eb7ed1df248eb25ffd2191 numpy1.15.0rc2cp34cp34mmanylinux1_x86_64.whl
558e102282d330234cfcc1b68e163e9ceb5baac26585a5506fd12c8ae406e0d2 numpy1.15.0rc2cp34nonewin32.whl
7db1973b8dd352a923c875c522c3f414c3e286fd12278e806ad635430cf7e906 numpy1.15.0rc2cp34nonewin_amd64.whl
8c962a352744e1f1df47665d12c24b59a8f30d6c1c492b6a1fb0a4be5a1a383c numpy1.15.0rc2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
3f9fa0257a0aab9ec18a205b3d5a10bf6c727913065d62fa61344604729559f4 numpy1.15.0rc2cp35cp35mmanylinux1_i686.whl
79049cfc7222de51bd8f58eddcd99196851a0401d91a82df293c6e9451b44b3e numpy1.15.0rc2cp35cp35mmanylinux1_x86_64.whl
0014321634f10f96f135b25183eaaa7fe595067534374f8ba80b9099ca90d74e numpy1.15.0rc2cp35nonewin32.whl
b12e5339885f291ff42c308aa1e0dd643899e2df73fa96b41121e2a921a0ac08 numpy1.15.0rc2cp35nonewin_amd64.whl
1a10572879d88786303e6ba12a9045b44a08d796b81a4fed3eaaaffa055c3730 numpy1.15.0rc2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2d2a599d500e1654a8b1ee6e2ff255a8b6a2aff432bed1507a43f0adce2d0793 numpy1.15.0rc2cp36cp36mmanylinux1_i686.whl
c8d1495be39a8f04ebf0dd6ef9a0c6818d68f572da884b9b8e860cff99066701 numpy1.15.0rc2cp36cp36mmanylinux1_x86_64.whl
8a858dc23e49ae8cc4f8a9ee4806e2a271c4fb897c88ffcc1e72407e6331ec43 numpy1.15.0rc2cp36nonewin32.whl
4f20759b5244e80a063aa2224d8fe7a14802572d6a96ebd95a13ba72b6d3d5cc numpy1.15.0rc2cp36nonewin_amd64.whl
0a1d8a25093527532109405482522e61eaa77d5618897a5783beeb0f04d27de8 numpy1.15.0rc2cp37cp37mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c3a0fee0fa2228288cfd0f5dc63f529dac46791fa8f489d3ad2ef99a3e2f37bd numpy1.15.0rc2cp37cp37mmanylinux1_i686.whl
5227554a410cf6dbefb76f63b53381a4761cf8c9e9ca2f0e3bab6a27110ef9c6 numpy1.15.0rc2cp37cp37mmanylinux1_x86_64.whl
67005ca9a63c65d7bef2c9200bc15165dee30b7c977fe1d8eef1c78f3270d3e5 numpy1.15.0rc2cp37nonewin32.whl
9886b43c330e122855b8b6573db8444dd0fe5a4b407f156f08305b7b441a564d numpy1.15.0rc2cp37nonewin_amd64.whl
917faceae30edd62f29a9cc16a6f70200fa07ae15228f3eda3d4555e16285484 numpy1.15.0rc2.tar.gz
e402d58467cec78c6fd7f60bacf7105bf31e2b863e4982bdf6b3c8f9d6ca9b23 numpy1.15.0rc2.zip
v1.15.0rc1
charris released this
Assets
==========================
NumPy 1.15.0 Release Notes
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.43.6. The upcoming
3.7 release should also work, but you will need to compile from source using
Cython 0.28.2 or later. The wheels will be linked with OpenBLAS 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.
New functions

numpy.gcd
andnumpy.lcm
, to compute the greatest common divisor and least
common multiple. 
numpy.ma.stack
, thenumpy.stack
arrayjoining function generalized to
masked arrays. 
numpy.quantile
function, an interface topercentile
without factors of
100 
numpy.nanquantile
function, an interface tonanpercentile
without
factors of 100 
numpy.printoptions
, a context manager that sets print options temporarily
for the scope of thewith
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
andnpy_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
unaliasedpickle.<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 inind = [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 asarr[[[0, 1], [0, 1]]]
, currently interpreted as
arr[array([0, 1]), array([0, 1])]
, that will be interpreted
asarr[array([[0, 1], [0, 1]])]
in the future. 
Imports from the following submodules 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 builtin Pythonsum
instead. 
Users of the CAPI should call
PyArrayResolveWriteBackIfCopy
or
PyArray_DiscardWritbackIfCopy
on any array with theWRITEBACKIFCOPY
flag set, before deallocating the array. A deprecation warning will be
emitted if those calls are not used when needed. 
Users of
numpy.nditer
should use the nditer object as a context manager
whenever one of the iterator operands is writeable so that numpy can manage
writeback semantics, or alternately, one can callit.close()
to trigger a
writeback. ARuntimeWarning
will otherwise be raised in those cases. Users
of the CAPI should callNpyIter_Close
beforeNpyIter_Deallocate
. 
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 callit.close()
. A
RuntimeWarning
may be emitted otherwise in these cases. 
The
normed
argument ofnp.histogram
, deprecated long ago in 1.6.0,
now emits aDeprecationWarning
.
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 errorprone 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 monkeypatches 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 noop. These
functions now behave consistently with np.copy()
.
Multifield Indexing of Structured Arrays will still return a copy
The change that multifield 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 function NpyIter_Close
The function NpyIter_Close
has been added and should be called before
NpyIter_Deallocate
to resolve possible writebackenabled arrays.
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 userdefined
copyswapn
/ copyswap
for userdefined 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>
__.
 Functions
npy_get_floatstatus_barrier
andnpy_clear_floatstatus_barrier
have been added and should be used in place of thenpy_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>
__.
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 arbitraryprecision Decimal
and long
types.
Support for crossplatform 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 iOScompatible 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 64bit RISCV architecture.
Improvements
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 unscoped 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 `histogramand
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 peraxis basis.
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
(peaktopeak) 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 numpyconvertible 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 inplace 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 nonsquare
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 1d 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 twodimensional 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 1dimensional arrays
(vectors), a single integer is accepted instead of a singleelement 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 shortcut 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
innerproduct example, keepdims=True, axes=[2, 2, 2]
would act on the
innerproduct example, keepdims=True, axis=2
would act on the
onebutlast 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
doubledouble floatingpointformat 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.
Checksums
MD5
ae603a7948555f5a877aa9e62d4de4a5 numpy1.15.0rc1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2b2bdf4a2e2d2be118740c036952b12a numpy1.15.0rc1cp27cp27mmanylinux1_i686.whl
d0f34f5a96b108e39c5f7c349de4b079 numpy1.15.0rc1cp27cp27mmanylinux1_x86_64.whl
91156245b11f2606fb9679ad11cd3788 numpy1.15.0rc1cp27cp27mumanylinux1_i686.whl
34f0cc01a35fd61bbf25ee64f2dac5ff numpy1.15.0rc1cp27cp27mumanylinux1_x86_64.whl
3d003bfc970de7364c7a509f1905b017 numpy1.15.0rc1cp27nonewin32.whl
2e63c6cef05817b00aec3550075e4a32 numpy1.15.0rc1cp27nonewin_amd64.whl
976c3898f88d06f2fd4e7e4acd454e37 numpy1.15.0rc1cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
faa3445ef691307efc371c82d34dbbfb numpy1.15.0rc1cp34cp34mmanylinux1_i686.whl
fe5ef50a0f8b21dd16283cbfd05ff438 numpy1.15.0rc1cp34cp34mmanylinux1_x86_64.whl
77bad7aeff1472e6777aedd62f6b7a06 numpy1.15.0rc1cp34nonewin32.whl
e8890f675820efb7718a02b071edb3d3 numpy1.15.0rc1cp34nonewin_amd64.whl
5a095e7fef444bb70cf43e33fd71a2b0 numpy1.15.0rc1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
cf92df0e604414593f21976b998f97ba numpy1.15.0rc1cp35cp35mmanylinux1_i686.whl
0cb3a14f65a556652a143fd8cdff21e6 numpy1.15.0rc1cp35cp35mmanylinux1_x86_64.whl
e146ae6eb6bd78b928ae624a9db6a323 numpy1.15.0rc1cp35nonewin32.whl
e77c2df92eec2f87a89b5ecffe31de8e numpy1.15.0rc1cp35nonewin_amd64.whl
ed423c6807ae7b5488546436259d281f numpy1.15.0rc1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d7455ee275bae39c68e130e4848ebb80 numpy1.15.0rc1cp36cp36mmanylinux1_i686.whl
a7e88e6d9c6f5bd59b354b16538a3cc5 numpy1.15.0rc1cp36cp36mmanylinux1_x86_64.whl
e5f8e934ff03979bdb3dc6041ef40859 numpy1.15.0rc1cp36nonewin32.whl
a0a932cc07062bb70ad9ff893b57d2b7 numpy1.15.0rc1cp36nonewin_amd64.whl
f6c1139993cce7bea5b78418ecf56ed1 numpy1.15.0rc1.tar.gz
ff5045d88b409bfeff664b13a110400e numpy1.15.0rc1.zip
SHA256
d5e4c5c34745d626d8f6613e4dd9b8d88b2dd9a52ea8764ed934cc5a8cb9cc22 numpy1.15.0rc1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
744d8c46272a5f2240fc750f7da1d831d90d0f1ce938d5540bcaabfb0f762a53 numpy1.15.0rc1cp27cp27mmanylinux1_i686.whl
9fe328aa046c5c9359d07f5161bdcdaaae8cd6d4fcf0761a41db424628f805d3 numpy1.15.0rc1cp27cp27mmanylinux1_x86_64.whl
85dbc672c5f2683147f5ee1af0793a5159411340f84fea99469dfd699def5bfd numpy1.15.0rc1cp27cp27mumanylinux1_i686.whl
9870ddc0055dbe5d77f1a7f5abd493737f0728f88e15fdafc459ea5e64a82efa numpy1.15.0rc1cp27cp27mumanylinux1_x86_64.whl
23ef8080613e5f8743b94d6e075e5894418a4a8a95a2eb7da3e524d180370512 numpy1.15.0rc1cp27nonewin32.whl
647dfec3cad0ab6a443a5661ad09cc35c2dd317f843909535d4183b05fea1860 numpy1.15.0rc1cp27nonewin_amd64.whl
fb78cb51abd23395a320b3608f35b8a2afcd76f32954184cf84b5db07e3c8649 numpy1.15.0rc1cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
baf9a2aa084e184cbf9b91702a26491fa263826ae941160527645cff84bf96b5 numpy1.15.0rc1cp34cp34mmanylinux1_i686.whl
2afb65982702da7905640afc63688b6b38c183f410e8df9dfb88c45a430d34f3 numpy1.15.0rc1cp34cp34mmanylinux1_x86_64.whl
00fa0b94566db5512fd402150dbadaeb38e0e78521673242f8ef687c343efcfe numpy1.15.0rc1cp34nonewin32.whl
fc1fa913fd0b3d80aed6744b7837176d755e0a6e023364db006c8d17679d64aa numpy1.15.0rc1cp34nonewin_amd64.whl
2d17cf40bd5b97c504fb4da00f1c0686c1ef9ebf363b8d5667269e66b07a2544 numpy1.15.0rc1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
01f46c1149d7571860f758299e5a0b6153d6d34f8821adf0c87d8d6f3e9517c5 numpy1.15.0rc1cp35cp35mmanylinux1_i686.whl
d80d04f9ea96c5d8fc27b0bc47122ad3459946f63fb49d26259decda25677221 numpy1.15.0rc1cp35cp35mmanylinux1_x86_64.whl
f2394a623f83c75dec54ab366ccac879ae01dcff9fa3391c97bda40c2b4b41b3 numpy1.15.0rc1cp35nonewin32.whl
3cff020d7beba3668c7e67a5921a4596a6abd917815691b93a5c87c5ae2f2ed3 numpy1.15.0rc1cp35nonewin_amd64.whl
ce9295610854f1dc749cc05a1f705539c983cfd4e99f3e7c01106f2d0f49d132 numpy1.15.0rc1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
8a211172894d6b21e8d2133dbdced490b95492707982cffce32b97fcada718ca numpy1.15.0rc1cp36cp36mmanylinux1_i686.whl
e16b6b066a19fb595eea0bd29ec0f9429af6bda3d0f7be3f31e57bff2b735ac5 numpy1.15.0rc1cp36cp36mmanylinux1_x86_64.whl
b1dcad0333986cbbbfa547d57807047d9777d5e1fd56c47eb47c59050e4485b1 numpy1.15.0rc1cp36nonewin32.whl
0e1871bb9307fbc3173c198f5536792185d20750cd5ad9907a14d49f767464b5 numpy1.15.0rc1cp36nonewin_amd64.whl
c57f33f83f61ad819e3fcb41afa54d224d03377d6f33be57289924cc193ead63 numpy1.15.0rc1.tar.gz
592657828982b13ff48a56c5f75fb2f286709f7b830ec211029ac7970027b54d numpy1.15.0rc1.zip
v1.14.5
mattip released this
Assets
NumPy 1.14.5 Release Notes
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 this release are 2.7 and 3.4  3.6. The Python
3.6 wheels available from PIP are built with Python 3.6.2 and should be
compatible with all previous versions of Python 3.6. The source releases were
cythonized with Cython 0.28.2 and should work for the upcoming Python 3.7.
Contributors
A total of 1 person contributed to this release. People with a "+" by their
names contributed a patch for the first time.
 Charles Harris
Pull requests merged
A total of 2 pull requests were merged for this release.
#11274 <https://github.com/numpy/numpy/pull/11274>
__: BUG: Correct use of NPY_UNUSED.#11294 <https://github.com/numpy/numpy/pull/11294>
__: BUG: Remove extra trailing parentheses.
Checksums
MD5
429afa5c8720016214a79779f774d3a4 numpy1.14.5cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
de8f5c6c0e46eedf8d92c1a7ba3fccf7 numpy1.14.5cp27cp27mmanylinux1_i686.whl
6315999b5142d22ce7bd9e74b1b4e3ab numpy1.14.5cp27cp27mmanylinux1_x86_64.whl
397a64608b5809983ff07842ebe0d353 numpy1.14.5cp27cp27mumanylinux1_i686.whl
6759e2f4bd57727f1ab9d6c9611b3f9d numpy1.14.5cp27cp27mumanylinux1_x86_64.whl
2d5609f384fccf9fe4e6172dd4fed3d0 numpy1.14.5cp27nonewin32.whl
c0d5fc38ab45f19cbd12200ff4ea45dd numpy1.14.5cp27nonewin_amd64.whl
0a77f36af749e5c3546c3d310f571256 numpy1.14.5cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ae15c8254a4a3ebfc45894617ce030a2 numpy1.14.5cp34cp34mmanylinux1_i686.whl
78c67b4b4f8f3f8bd9c2f897f9d40f60 numpy1.14.5cp34cp34mmanylinux1_x86_64.whl
5263ec59028d508992c15263993698d0 numpy1.14.5cp34nonewin32.whl
193365c9f1bb2086b47afe9c797ff415 numpy1.14.5cp34nonewin_amd64.whl
90caeba061eec5dbebadad5c8bad3a0c numpy1.14.5cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
129848206c41b68071fe9cb469a66846 numpy1.14.5cp35cp35mmanylinux1_i686.whl
395c0058b7ec0ae0cad1e052362e9aeb numpy1.14.5cp35cp35mmanylinux1_x86_64.whl
a542ea0d9047df0da8ab69e90d60dbdc numpy1.14.5cp35nonewin32.whl
c5c86e11b5071c0ca0bb11f6a84f20e6 numpy1.14.5cp35nonewin_amd64.whl
350120bd20a0a45857b4c39e901af41b numpy1.14.5cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
5a0682a984fcf6f87a9f10760d896b70 numpy1.14.5cp36cp36mmanylinux1_i686.whl
c5596c3d232345d0f0176cd02e6efe92 numpy1.14.5cp36cp36mmanylinux1_x86_64.whl
c0306cbad68f8084e977121ba104b634 numpy1.14.5cp36nonewin32.whl
01b5bd7897e1306660c7ea6a30391cc4 numpy1.14.5cp36nonewin_amd64.whl
e3189ee851c3a0e2e6e4c6e80a711ec8 numpy1.14.5.tar.gz
02d940a6931703de2c41fa5590ac7e98 numpy1.14.5.zip
SHA256
e1864a4e9f93ddb2dc6b62ccc2ec1f8250ff4ac0d3d7a15c8985dd4e1fbd6418 numpy1.14.5cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
085afac75bbc97a096744fcfc97a4b321c5a87220286811e85089ae04885acdd numpy1.14.5cp27cp27mmanylinux1_i686.whl
6c57f973218b776195d0356e556ec932698f3a563e2f640cfca7020086383f50 numpy1.14.5cp27cp27mmanylinux1_x86_64.whl
589336ba5199c8061239cf446ee2f2f1fcc0c68e8531ee1382b6fc0c66b2d388 numpy1.14.5cp27cp27mumanylinux1_i686.whl
5edf1acc827ed139086af95ce4449b7b664f57a8c29eb755411a634be280d9f2 numpy1.14.5cp27cp27mumanylinux1_x86_64.whl
6b82b81c6b3b70ed40bc6d0b71222ebfcd6b6c04a6e7945a936e514b9113d5a3 numpy1.14.5cp27nonewin32.whl
385f1ce46e08676505b692bfde918c1e0b350963a15ef52d77691c2cf0f5dbf6 numpy1.14.5cp27nonewin_amd64.whl
758d1091a501fd2d75034e55e7e98bfd1370dc089160845c242db1c760d944d9 numpy1.14.5cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c725d11990a9243e6ceffe0ab25a07c46c1cc2c5dc55e305717b5afe856c9608 numpy1.14.5cp34cp34mmanylinux1_i686.whl
07379fe0b450f6fd6e5934a9bc015025bb4ce1c8fbed3ca8bef29328b1bc9570 numpy1.14.5cp34cp34mmanylinux1_x86_64.whl
9e1f53afae865cc32459ad211493cf9e2a3651a7295b7a38654ef3d123808996 numpy1.14.5cp34nonewin32.whl
4d278c2261be6423c5e63d8f0ceb1b0c6db3ff83f2906f4b860db6ae99ca1bb5 numpy1.14.5cp34nonewin_amd64.whl
d696a8c87315a83983fc59dd27efe034292b9e8ad667aeae51a68b4be14690d9 numpy1.14.5cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2df854df882d322d5c23087a4959e145b953dfff2abe1774fec4f639ac2f3160 numpy1.14.5cp35cp35mmanylinux1_i686.whl
baadc5f770917ada556afb7651a68176559f4dca5f4b2d0947cd15b9fb84fb51 numpy1.14.5cp35cp35mmanylinux1_x86_64.whl
2d6481c6bdab1c75affc0fc71eb1bd4b3ecef620d06f2f60c3f00521d54be04f numpy1.14.5cp35nonewin32.whl
51c5dcb51cf88b34b7d04c15f600b07c6ccbb73a089a38af2ab83c02862318da numpy1.14.5cp35nonewin_amd64.whl
8b8dcfcd630f1981f0f1e3846fae883376762a0c1b472baa35b145b911683b7b numpy1.14.5cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
9d69967673ab7b028c2df09cae05ba56bf4e39e3cb04ebe452b6035c3b49848e numpy1.14.5cp36cp36mmanylinux1_i686.whl
8622db292b766719810e0cb0f62ef6141e15fe32b04e4eb2959888319e59336b numpy1.14.5cp36cp36mmanylinux1_x86_64.whl
97fa8f1dceffab782069b291e38c4c2227f255cdac5f1e3346666931df87373e numpy1.14.5cp36nonewin32.whl
381ad13c30cd1d0b2f3da8a0c1a4aa697487e8bb0e9e0cbeb7439776bcb645f8 numpy1.14.5cp36nonewin_amd64.whl
1b4a02758fb68a65ea986d808867f1d6383219c234aef553a8741818e795b529 numpy1.14.5.tar.gz
a4a433b3a264dbc9aa9c7c241e87c0358a503ea6394f8737df1683c7c9a102ac numpy1.14.5.zip
v1.14.4
charris released this
Assets
==========================
NumPy 1.14.4 Release Notes
This is a bugfix release for bugs reported following the 1.14.3 release. The
most significant fixes are:

fixes for compiler instruction reordering that resulted in NaN's not being
properly propagated innp.max
andnp.min
, 
fixes for bus faults on SPARC and older ARM due to incorrect alignment
checks.
There are also improvements to printing of long doubles on PPC platforms. All
is not yet perfect on that platform, the whitespace padding is still incorrect
and is to be fixed in numpy 1.15, consequently NumPy still fails some
printingrelated (and other) unit tests on ppc systems. However, the printed
values are now correct.
Note that NumPy will error on import if it detects incorrect float32 dot
results. This problem has been seen on the Mac when working in the Anaconda
enviroment and is due to a subtle interaction between MKL and PyQt5. It is not
strictly a NumPy problem, but it is best that users be aware of it. See the
gh8577 NumPy issue for more information.
The Python versions supported in this release are 2.7 and 3.4  3.6. The Python
3.6 wheels available from PIP are built with Python 3.6.2 and should be
compatible with all previous versions of Python 3.6. The source releases were
cythonized with Cython 0.28.2 and should work for the upcoming Python 3.7.
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
 Marten van Kerkwijk
 Matti Picus
 Pauli Virtanen
 Ryan Soklaski +
 Sebastian Berg
Pull requests merged
A total of 11 pull requests were merged for this release.
 #11104: BUG: str of DOUBLE_DOUBLE format wrong on ppc64
 #11170: TST: linalg: add regression test for gh8577
 #11174: MAINT: add sanitychecks to be run at import time
 #11181: BUG: void dtype setup checked offset not actual pointer for alignment
 #11194: BUG: Python2 doubles don't print correctly in interactive shell.
 #11198: BUG: optimizing compilers can reorder call to npy_get_floatstatus
 #11199: BUG: reduce using SSE only warns if inside SSE loop
 #11203: BUG: Bytes delimiter/comments in genfromtxt should be decoded
 #11211: BUG: Fix reference count/memory leak exposed by better testing
 #11219: BUG: Fixes einsum broadcasting bug when optimize=True
 #11251: DOC: Document 1.14.4 release.
Checksums
MD5
118e010f76fba91f05111e775d08b9d2 numpy1.14.4cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a08af11af72e8393d61f1724e2a42258 numpy1.14.4cp27cp27mmanylinux1_i686.whl
bbf56f4de32bb2c4215e01ea4f1b9445 numpy1.14.4cp27cp27mmanylinux1_x86_64.whl
b5e17dcc08205a278ffd33c6baeb7562 numpy1.14.4cp27cp27mumanylinux1_i686.whl
e6844d6134fed4f79b52cd89d66edb76 numpy1.14.4cp27cp27mumanylinux1_x86_64.whl
e9d4ab30ffee0f57da2292ed2c42bdcb numpy1.14.4cp27nonewin32.whl
ff04e3451a90fdf9ae8b6db8b3e8c2d6 numpy1.14.4cp27nonewin_amd64.whl
fbe6a5a9a0de9f85bcb729702a132769 numpy1.14.4cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
33a177cf9d60fa26d30dc80b7163a374 numpy1.14.4cp34cp34mmanylinux1_i686.whl
6335ee571648d8db7561a619328b69c7 numpy1.14.4cp34cp34mmanylinux1_x86_64.whl
e53dd3796a0cdec43037b18c5c54d1a3 numpy1.14.4cp34nonewin32.whl
aab911c898c58073b47a2d1f28228a41 numpy1.14.4cp34nonewin_amd64.whl
a05e215d9443c838a531119eb5c1eadc numpy1.14.4cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
7c5f7ff2cccb13c22b87f768ac1cc6e2 numpy1.14.4cp35cp35mmanylinux1_i686.whl
d22105d03a15c9fd6ec4ecffa4b1f764 numpy1.14.4cp35cp35mmanylinux1_x86_64.whl
7a5d4c66c7f6e430eb73b5683d99cacb numpy1.14.4cp35nonewin32.whl
cf0c074d9243f8bf6eff8291ac12a003 numpy1.14.4cp35nonewin_amd64.whl
79233bdad30a65beb515c86a4612102d numpy1.14.4cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
135139bd2ec26e2b52bdd2d36be94c44 numpy1.14.4cp36cp36mmanylinux1_i686.whl
9c56d525cf6da2b8489e723d72ccc9a2 numpy1.14.4cp36cp36mmanylinux1_x86_64.whl
ec9af9e19aac597e1a245ada9c333e2d numpy1.14.4cp36nonewin32.whl
f8ec9c6167f2b0d08066ec78c3a01a4c numpy1.14.4cp36nonewin_amd64.whl
7de00fc3be91a3ab913d4efe206b3928 numpy1.14.4.tar.gz
a8a23723342a561e579757553e9db73a numpy1.14.4.zip
SHA256
c0c4bdcb771a147cb14286e3aeb72267e1664652d4150b0df255f0c210166a62 numpy1.14.4cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
939376b3b8d9bd42529a2713534c9bae7f11c774614d4d2f7f2a38cae96101f1 numpy1.14.4cp27cp27mmanylinux1_i686.whl
6105d909e56c4f3f173a7294154eee5da80853104e9c3ebcf9e523fb3bb6cf70 numpy1.14.4cp27cp27mmanylinux1_x86_64.whl
3ed68b8ef0635e12b06c216d3ed33572d9c15b05a5a5d6ab870d073190c3eef3 numpy1.14.4cp27cp27mumanylinux1_i686.whl
1dc831683f18c11e6b5b7ad3610b9f00417b8d3fc63a8adcdbe68844d9dd6f62 numpy1.14.4cp27cp27mumanylinux1_x86_64.whl
8d87ac65d830ee3087e6bd02b0201e68aed4c715ff2e227e3640e7ded38d8a2e numpy1.14.4cp27nonewin32.whl
7fbceea93b6877419d84516705a265dfc4626939a29107a4d04db599bf6cdf8d numpy1.14.4cp27nonewin_amd64.whl
a1b4a80d59658fc438716095deb1971c6315482b461d976f760d920b6509fd5d numpy1.14.4cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ef7a07f6a77658a1038e6d22e53458129c04a95b5770f080b5741320d9491e32 numpy1.14.4cp34cp34mmanylinux1_i686.whl
c5065b3aec37cd1b7ec2882b3ab86e200d15219a0fb96fea65a16c6b59d3c0f0 numpy1.14.4cp34cp34mmanylinux1_x86_64.whl
b2b2741da83b1e016094b2fef2cadec1abd3ccd3d97428634ec6afe1dcb699b8 numpy1.14.4cp34nonewin32.whl
419dfe9bcb09d2e87ecf296c5ebf2b047c568419c89588acc9dbce6d2d761bea numpy1.14.4cp34nonewin_amd64.whl
be4664fe153ca6dbd961fb06f99b9b88b114ab44649376253b540aafbf42e469 numpy1.14.4cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0d6d7bbcb54babaf39fe658bcc6f79641c9c62813c6d477802d783c7ba1a437c numpy1.14.4cp35cp35mmanylinux1_i686.whl
f54114395aabe13c7c4e4b425145cfd998eaf0781e87a9e9b2e77426f1ec8a82 numpy1.14.4cp35cp35mmanylinux1_x86_64.whl
eb6ccd2b47d43199ec9a7c39bd45e399ccb5756e7367aaf92ced3c46fa67b16b numpy1.14.4cp35nonewin32.whl
f6a4ae8d5e1126bf4d8520a9aa6a82d067ab3ce7d21f58f0d50ead2aebda7bfb numpy1.14.4cp35nonewin_amd64.whl
b037993dfb1175a68b6a2bfc6b1c2af57c09031d1332fea3ab25a539b43bd475 numpy1.14.4cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e6c24c83ca64d447a18f041bd53cbe96c74405f59939b6006755105583b62629 numpy1.14.4cp36cp36mmanylinux1_i686.whl
f29a9c5607b0fded7a9f0871dbd06918a88cb0a465acfac5c67f92d1a4115d48 numpy1.14.4cp36cp36mmanylinux1_x86_64.whl
d9ceb6c680ffbe55ef6cf9d93558e0ddb72d616b885d77c536920f3da2112703 numpy1.14.4cp36nonewin32.whl
9e6694912f13afd8b1e15aa8002e9c951a377c94080c5442de154d743a69b3ff numpy1.14.4cp36nonewin_amd64.whl
c9a83644685edf8b5383b7632daa37df115b41aa20ca6ec3139e707d88f7c903 numpy1.14.4.tar.gz
2185a0f31ecaa0792264fa968c8e0ba6d96acf144b26e2e1d1cd5b77fc11a691 numpy1.14.4.zip
v1.14.3
ahaldane released this
Assets
==========================
NumPy 1.14.3 Release Notes
This is a bugfix release for a few bugs reported following the 1.14.2 release:
 np.lib.recfunctions.fromrecords accepts a listoflists, until 1.15
 In python2, float types use the new print style when printing to a file
 style arg in "legacy" print mode now works for 0d arrays
The Python versions supported in this release are 2.7 and 3.4  3.6. The Python
3.6 wheels available from PIP are built with Python 3.6.2 and should be
compatible with all previous versions of Python 3.6. The source releases were
cythonized with Cython 0.28.2.
Contributors
A total of 6 people contributed to this release. People with a "+" by their
names contributed a patch for the first time.
 Allan Haldane
 Charles Harris
 Jonathan March +
 Malcolm Smith +
 Matti Picus
 Pauli Virtanen
Pull requests merged
A total of 8 pull requests were merged for this release.
 #10862: BUG: floating types should override tp_print (1.14 backport)
 #10905: BUG: for 1.14 backcompat, accept listoflists in fromrecords
 #10947: BUG: 'style' arg to array2string broken in legacy mode (1.14...
 #10959: BUG: test, fix for missing flags['WRITEBACKIFCOPY'] key
 #10960: BUG: Add missing underscore to prototype in check_embedded_lapack
 #10961: BUG: Fix encoding regression in ma/bench.py (Issue #10868)
 #10962: BUG: core: fix NPY_TITLE_KEY macro on pypy
 #10974: BUG: test, fix PyArray_DiscardWritebackIfCopy...
Checksums
MD5
14b675b1f5c0e33dea22735df8ecf5d1 numpy1.14.3cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
501b9237037beee4c1262180c317f527 numpy1.14.3cp27cp27mmanylinux1_i686.whl
51f3c8de7bac77ce864a8a28dc0c3f10 numpy1.14.3cp27cp27mmanylinux1_x86_64.whl
37bfe26b655464a77356ee053deafad2 numpy1.14.3cp27cp27mumanylinux1_i686.whl
c8243f0d6a77c88acf48235aaedf1497 numpy1.14.3cp27cp27mumanylinux1_x86_64.whl
9c616eb6134c92ca42cca5883e7861b7 numpy1.14.3cp27nonewin32.whl
fa3f732464bc83eb08fc6748aeb01ba0 numpy1.14.3cp27nonewin_amd64.whl
711dd188cf3269e092adb4240742731b numpy1.14.3cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0450e19513ff2406055bdffcdfef8d82 numpy1.14.3cp34cp34mmanylinux1_i686.whl
1a0fc864b3b1aea403b426eb2e83276c numpy1.14.3cp34cp34mmanylinux1_x86_64.whl
13fa200925025289dbd120078c54377f numpy1.14.3cp34nonewin32.whl
fc74d7d13da26e2ffc8bf39d5c24d171 numpy1.14.3cp34nonewin_amd64.whl
faee14118dea28c6e2be5aadaa1613ca numpy1.14.3cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e93edc38b9e31d774af60b45ad25d3d7 numpy1.14.3cp35cp35mmanylinux1_i686.whl
6d7ced18705cdd82030472b7a0b106c9 numpy1.14.3cp35cp35mmanylinux1_x86_64.whl
42000f9cfef06906e25c0020a9c92366 numpy1.14.3cp35nonewin32.whl
b7cd0a630d24ef8ed245cde71e50c46e numpy1.14.3cp35nonewin_amd64.whl
d728ee343c54c8b9b1186747bae6800b numpy1.14.3cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0f8ed907b7c37d7e8c0508ee30ac5e0b numpy1.14.3cp36cp36mmanylinux1_i686.whl
04428f5a071531dd463504250c194de3 numpy1.14.3cp36cp36mmanylinux1_x86_64.whl
a376953ac6bfca04371899d70126ebd4 numpy1.14.3cp36nonewin32.whl
955959dbc1a743308bfcafb4d867da29 numpy1.14.3cp36nonewin_amd64.whl
7c3c806ae27196c92d2fb3fbd4991e81 numpy1.14.3.tar.gz
97416212c0a172db4bc6b905e9c4634b numpy1.14.3.zip
SHA256
a8dbab311d4259de5eeaa5b4e83f5f8545e4808f9144e84c0f424a6ee55a7b98 numpy1.14.3cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
034717bfef517858abc79324820a702dc6cd063effb9baab86533e8a78670689 numpy1.14.3cp27cp27mmanylinux1_i686.whl
f39afab5769b3aaa786634b94b4a23ef3c150bdda044e8a32a3fc16ddafe803b numpy1.14.3cp27cp27mmanylinux1_x86_64.whl
8670067685051b49d1f2f66e396488064299fefca199c7c80b6ba0c639fedc98 numpy1.14.3cp27cp27mumanylinux1_i686.whl
0db6301324d0568089663ef2701ad90ebac0e975742c97460e89366692bd0563 numpy1.14.3cp27cp27mumanylinux1_x86_64.whl
98ff275f1b5907490d26b30b6ff111ecf2de0254f0ab08833d8fe61aa2068a00 numpy1.14.3cp27nonewin32.whl
aaef1bea636b6e552bbc5dae0ada87d4f6046359daaa97a05a013b0169620f27 numpy1.14.3cp27nonewin_amd64.whl
760550fdf9d8ec7da9c4402a4afe6e25c0f184ae132011676298a6b636660b45 numpy1.14.3cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e8578a62a8eaf552b95d62f630bb5dd071243ba1302bbff3e55ac48588508736 numpy1.14.3cp34cp34mmanylinux1_i686.whl
e33baf50f2f6b7153ddb973601a11df852697fba4c08b34a5e0f39f66f8120e1 numpy1.14.3cp34cp34mmanylinux1_x86_64.whl
0074d42e2cc333800bd09996223d40ec52e3b1ec0a5cab05dacc09b662c4c1ae numpy1.14.3cp34nonewin32.whl
c3fe23df6fe0898e788581753da453f877350058c5982e85a8972feeecb15309 numpy1.14.3cp34nonewin_amd64.whl
1864d005b2eb7598063e35c320787d87730d864f40d6410f768fe4ea20672016 numpy1.14.3cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
f22b3206f1c561dd9110b93d144c6aaa4a9a354e3b07ad36030df3ea92c5bb5b numpy1.14.3cp35cp35mmanylinux1_i686.whl
c80fcf9b38c7f4df666150069b04abbd2fe42ae640703a6e1f128cda83b552b7 numpy1.14.3cp35cp35mmanylinux1_x86_64.whl
510863d606c932b41d2209e4de6157ab3fdf52001d3e4ad351103176d33c4b8b numpy1.14.3cp35nonewin32.whl
c5eb7254cfc4bd7a4330ad7e1f65b98343836865338c57b0e25c661e41d5cfd9 numpy1.14.3cp35nonewin_amd64.whl
b8987e30d9a0eb6635df9705a75cf8c4a2835590244baecf210163343bc65176 numpy1.14.3cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
57dc6c22d59054542600fce6fae2d1189b9c50bafc1aab32e55f7efcc84a6c46 numpy1.14.3cp36cp36mmanylinux1_i686.whl
46ce8323ca9384814c7645298b8b627b7d04ce97d6948ef02da357b2389d6972 numpy1.14.3cp36cp36mmanylinux1_x86_64.whl
9ccf4d5c9139b1e985db915039baa0610a7e4a45090580065f8d8cb801b7422f numpy1.14.3cp36nonewin32.whl
560e23a12e7599be8e8b67621396c5bc687fd54b48b890adbc71bc5a67333f86 numpy1.14.3cp36nonewin_amd64.whl
cfcfc7a9a8ba4275c60a815c683d59ac5e7aa9362d76573b6cc4324ffb1235fa numpy1.14.3.tar.gz
9016692c7d390f9d378fc88b7a799dc9caa7eb938163dda5276d3f3d6f75debf numpy1.14.3.zip
v1.14.2
charris released this
Assets
==========================
NumPy 1.14.2 Release Notes
This is a bugfix release for some bugs reported following the 1.14.1 release. The major
problems dealt with are as follows.
 Residual bugs in the new array printing functionality.
 Regression resulting in a relocation problem with shared library.
 Improved PyPy compatibility.
The Python versions supported in this release are 2.7 and 3.4  3.6. The Python
3.6 wheels available from PIP are built with Python 3.6.2 and should be
compatible with all previous versions of Python 3.6. The source releases were
cythonized with Cython 0.26.1, which is known to not support the upcoming
Python 3.7 release. People who wish to run Python 3.7 should check out the
NumPy repo and try building with the, as yet, unreleased master branch of
Cython.
Contributors
A total of 4 people contributed to this release. People with a "+" by their
names contributed a patch for the first time.
 Allan Haldane
 Charles Harris
 Eric Wieser
 Pauli Virtanen
Pull requests merged
A total of 5 pull requests were merged for this release.
 #10674: BUG: Further backcompat fix for subclassed array repr
 #10725: BUG: dragon4 fractional output mode adds too many trailing zeros
 #10726: BUG: Fix f2py generated code to work on PyPy
 #10727: BUG: Fix missing NPY_VISIBILITY_HIDDEN on npy_longdouble_to_PyLong
 #10729: DOC: Create 1.14.2 notes and changelog.
Checksums
MD5
9bb06966218d0f3d0a25a6155c7d2439 numpy1.14.2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b8a260b915d44475f4385fed4c6a7ec8 numpy1.14.2cp27cp27mmanylinux1_i686.whl
7733aa702cebb5b0469b820ea9cfc293 numpy1.14.2cp27cp27mmanylinux1_x86_64.whl
ef1065f3ecd08054eca9c6c14a2e3518 numpy1.14.2cp27cp27mumanylinux1_i686.whl
1227a63fcc8ce91a75d2ab006d406df7 numpy1.14.2cp27cp27mumanylinux1_x86_64.whl
6ac633c46c13dd2af93761460d63436e numpy1.14.2cp27nonewin32.whl
187a94722b84d65cc3a9ecfce27ee3b2 numpy1.14.2cp27nonewin_amd64.whl
580340cfe4a14f8a9e1d781d7b42955b numpy1.14.2cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
7f38fb83008ed4bb8217840ac27aeba4 numpy1.14.2cp34cp34mmanylinux1_i686.whl
cbe383ad27db21767b6ffdd943e3df9c numpy1.14.2cp34cp34mmanylinux1_x86_64.whl
350a1e0f0c825ffa1de264108c648482 numpy1.14.2cp34nonewin32.whl
ececd9b8891d801d4a968c2ec5eac7bb numpy1.14.2cp34nonewin_amd64.whl
8a74bb1f94ad8c1ad8f37e73f967b850 numpy1.14.2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c1231d7e7fc52c09dff9a529ad228818 numpy1.14.2cp35cp35mmanylinux1_i686.whl
ef57856bf6dade82922ab58922756dd0 numpy1.14.2cp35cp35mmanylinux1_x86_64.whl
8c98ab081112832e3a7faca624598119 numpy1.14.2cp35nonewin32.whl
2652e9660be5d074224d14436504f008 numpy1.14.2cp35nonewin_amd64.whl
1cdb6cf8d60dfbe99f60639dac38471e numpy1.14.2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
b11c80344b84853b7a24acc51bbe4945 numpy1.14.2cp36cp36mmanylinux1_i686.whl
65c3802c0f25f2d26aa784433643f655 numpy1.14.2cp36cp36mmanylinux1_x86_64.whl
8f9986b323d4215925d6cfa1cd1bc14d numpy1.14.2cp36nonewin32.whl
9d78ceef101313f49fd0b8fed25d889c numpy1.14.2cp36nonewin_amd64.whl
e39878fafb11828983aeec583dda4a06 numpy1.14.2.tar.gz
080f01a19707cf467393e426382c7619 numpy1.14.2.zip
SHA256
719d914f564f35cce4dc103808f8297c807c9f0297ac183ed81ae8b5650e698e numpy1.14.2cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0f6a5ed0cd7ab1da11f5c07a8ecada73fc55a70ef7bb6311a4109891341d7277 numpy1.14.2cp27cp27mmanylinux1_i686.whl
d0928076d9bd8a98de44e79b1abe50c1456e7abbb40af7ef58092086f1a6c729 numpy1.14.2cp27cp27mmanylinux1_x86_64.whl
d858423f5ed444d494b15c4cc90a206e1b8c31354c781ac7584da0d21c09c1c3 numpy1.14.2cp27cp27mumanylinux1_i686.whl
20cac3123d791e4bf8482a580d98d6b5969ba348b9d5364df791ba3a666b660d numpy1.14.2cp27cp27mumanylinux1_x86_64.whl
528ce59ded2008f9e8543e0146acb3a98a9890da00adf8904b1e18c82099418b numpy1.14.2cp27nonewin32.whl
56e392b7c738bd70e6f46cf48c8194d3d1dd4c5a59fae4b30c58bb6ef86e5233 numpy1.14.2cp27nonewin_amd64.whl
99051e03b445117b26028623f1a487112ddf61a09a27e2d25e6bc07d37d94f25 numpy1.14.2cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
768e777cc1ffdbf97c507f65975c8686ebafe0f3dc8925d02ac117acc4669ce9 numpy1.14.2cp34cp34mmanylinux1_i686.whl
675e0f23967ce71067d12b6944add505d5f0a251f819cfb44bdf8ee7072c090d numpy1.14.2cp34cp34mmanylinux1_x86_64.whl
a958bf9d4834c72dee4f91a0476e7837b8a2966dc6fcfc42c421405f98d0da51 numpy1.14.2cp34nonewin32.whl
bb370120de6d26004358611441e07acda26840e41dfedc259d7f8cc613f96495 numpy1.14.2cp34nonewin_amd64.whl
f2b1378b63bdb581d5d7af2ec0373c8d40d651941d283a2afd7fc71184b3f570 numpy1.14.2cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a1413d06abfa942ca0553bf3bccaff5fdb36d55b84f2248e36228db871147dab numpy1.14.2cp35cp35mmanylinux1_i686.whl
7f76d406c6b998d6410198dcb82688dcdaec7d846aa87e263ccf52efdcfeba30 numpy1.14.2cp35cp35mmanylinux1_x86_64.whl
a7157c9ac6bddd2908c35ef099e4b643bc0e0ebb4d653deb54891d29258dd329 numpy1.14.2cp35nonewin32.whl
0fd65cbbfdbf76bbf80c445d923b3accefea0fe2c2082049e0ce947c81fe1d3f numpy1.14.2cp35nonewin_amd64.whl
8c18ee4dddd5c6a811930c0a7c7947bf16387da3b394725f6063f1366311187d numpy1.14.2cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0739146eaf4985962f07c62f7133aca89f3a600faac891ce6c7f3a1e2afe5272 numpy1.14.2cp36cp36mmanylinux1_i686.whl
07e21f14490324cc1160db101e9b6c1233c33985af4cb1d301dd02650fea1d7f numpy1.14.2cp36cp36mmanylinux1_x86_64.whl
e6120d63b50e2248219f53302af7ec6fa2a42ed1f37e9cda2c76dbaca65036a7 numpy1.14.2cp36nonewin32.whl
6be6b0ca705321c178c9858e5ad5611af664bbdfae1df1541f938a840a103888 numpy1.14.2cp36nonewin_amd64.whl
ddbcda194f49e0cf0663fa8131cb9d7a3b876d14dea0047d3c5fdfaf20adbb40 numpy1.14.2.tar.gz
facc6f925c3099ac01a1f03758100772560a0b020fb9d70f210404be08006bcb numpy1.14.2.zip
v1.14.1
charris released this
Assets
==========================
NumPy 1.14.1 Release Notes
This is a bugfix release for some problems reported following the 1.14.0 release. The major
problems fixed are the following.
 Problems with the new array printing, particularly the printing of complex
values, Please report any additional problems that may turn up.  Problems with
np.einsum
due to the newoptimized=True
default. Some
fixes for optimization have been applied andoptimize=False
is now the
default.  The sort order in
np.unique
whenaxis=<somenumber>
will now always
be lexicographic in the subarray elements. In previous NumPy versions there
was an optimization that could result in sorting the subarrays as unsigned
byte strings.  The change in 1.14.0 that multifield indexing of structured arrays returns a
view instead of a copy has been reverted but remains on track for NumPy 1.15.
Affected users should read the 1.14.1 Numpy User Guide section
"basics/structured arrays/accessing multiple fields" for advice on how to
manage this transition.
The Python versions supported in this release are 2.7 and 3.4  3.6. The Python
3.6 wheels available from PIP are built with Python 3.6.2 and should be
compatible with all previous versions of Python 3.6. The source releases were
cythonized with Cython 0.26.1, which is known to not support the upcoming
Python 3.7 release. People who wish to run Python 3.7 should check out the
NumPy repo and try building with the, as yet, unreleased master branch of
Cython.
Contributors
A total of 14 people contributed to this release. People with a "+" by their
names contributed a patch for the first time.
 Allan Haldane
 Charles Harris
 Daniel Smith
 Dennis Weyland +
 Eric Larson
 Eric Wieser
 Jarrod Millman
 Kenichi Maehashi +
 Marten van Kerkwijk
 Mathieu Lamarre
 Sebastian Berg
 Simon Conseil
 Simon Gibbons
 xoviat
Pull requests merged
A total of 36 pull requests were merged for this release.
 #10339: BUG: restrict the config modifications to win32
 #10368: MAINT: Adjust type promotion in linalg.norm
 #10375: BUG: add missing paren and remove quotes from repr of fieldless...
 #10395: MAINT: Update download URL in setup.py.
 #10396: BUG: fix einsum issue with unicode input and py2
 #10397: BUG: fix error message not formatted in einsum
 #10398: DOC: add documentation about how to handle new array printing
 #10403: BUG: Set einsum optimize parameter default to
False
.  #10424: ENH: Fix repr of np.record objects to match np.void types #10412
 #10425: MAINT: Update zesty to artful for i386 testing
 #10431: REL: Add 1.14.1 release notes template
 #10435: MAINT: Use ValueError for duplicate field names in lookup (backport)
 #10534: BUG: Provide a better error message for outoforder fields
 #10536: BUG: Resize bytes_ columns in genfromtxt (backport of #10401)
 #10537: BUG: multifieldindexing adds padding bytes: revert for 1.14.1
 #10539: BUG: fix np.save issue with python 2.7.5
 #10540: BUG: Add missing DECREF in Py2 int() cast
 #10541: TST: Add circleci document testing to maintenance/1.14.x
 #10542: BUG: complex repr has extra spaces, missing + (1.14 backport)
 #10550: BUG: Set missing exception after malloc
 #10557: BUG: In numpy.i, clear CARRAY flag if wrapped buffer is not C_CONTIGUOUS.
 #10558: DEP: Issue FutureWarning when malformed records detected.
 #10559: BUG: Fix einsum optimize logic for singleton dimensions
 #10560: BUG: Fix calling ufuncs with a positional output argument.
 #10561: BUG: Fix various BigEndian test failures (ppc64)
 #10562: BUG: Make dtype.descr error for outoforder fields.
 #10563: BUG: arrays not being flattened in
union1d
 #10607: MAINT: Update sphinxext submodule hash.
 #10608: BUG: Revert sort optimization in np.unique.
 #10609: BUG: infinite recursion in str of 0d subclasses
 #10610: BUG: Align type definition with generated lapack
 #10612: BUG/ENH: Improve output for structured nonvoid types
 #10622: BUG: deallocate recursive closure in arrayprint.py (1.14 backport)
 #10624: BUG: Correctly identify comma seperated dtype strings
 #10629: BUG: deallocate recursive closure in arrayprint.py (backport...
 #10630: REL: Prepare for 1.14.1 release.
Checksums
MD5
8a56c4b06e859ccad60a85d3486b214a numpy1.14.1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
94189ecffbc1032df54f570bb6ff490d numpy1.14.1cp27cp27mmanylinux1_i686.whl
61473860888d024caa1261274620352e numpy1.14.1cp27cp27mmanylinux1_x86_64.whl
f9f6ada0f110230569cea9d8d2f5416a numpy1.14.1cp27cp27mumanylinux1_i686.whl
0c2c6637c5c8ca639e1b7b3fa4ac64cc numpy1.14.1cp27cp27mumanylinux1_x86_64.whl
dbae0fec3c033b42695d9df9636ba9a5 numpy1.14.1cp27nonewin32.whl
c7ee8517a1a52b90f08651c1f17b6e39 numpy1.14.1cp27nonewin_amd64.whl
bb051505823a3f990ea22750a08cd40b numpy1.14.1cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
655f4c67598dfe583fce3075e0152b06 numpy1.14.1cp34cp34mmanylinux1_i686.whl
94cdf22837fdec46d03709fe0338ee09 numpy1.14.1cp34cp34mmanylinux1_x86_64.whl
5b7fc9eb18463356ed8d018a3b486d53 numpy1.14.1cp34nonewin32.whl
b261be176aa57dce8a64f4fac169c74b numpy1.14.1cp34nonewin_amd64.whl
196639515a2084dc5b4b86a5ea0247ce numpy1.14.1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d897ae36d1487a101714deeb8782b7c5 numpy1.14.1cp35cp35mmanylinux1_i686.whl
12f2c45cc7501dc5a5e670042300f1e6 numpy1.14.1cp35cp35mmanylinux1_x86_64.whl
e94355704fe2f6b3d1bcf6c8f6189df4 numpy1.14.1cp35nonewin32.whl
13b79737d10e857ee808a1dfdd2ff01e numpy1.14.1cp35nonewin_amd64.whl
8819860639f492ddf6045a95227624d0 numpy1.14.1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
2b3d5774779e808cef193872dd4f6dbe numpy1.14.1cp36cp36mmanylinux1_i686.whl
dd2321ea4590ec05d825d8c9a64fd64b numpy1.14.1cp36cp36mmanylinux1_x86_64.whl
a5803be2b83c1ec5f36ed9f58a0f848c numpy1.14.1cp36nonewin32.whl
299c92352d2c08baa6a8142971b39295 numpy1.14.1cp36nonewin_amd64.whl
0e09f20f62ab9f8a02cb7bd3fd023482 numpy1.14.1.tar.gz
b8324ef90ac9064cd0eac46b8b388674 numpy1.14.1.zip
SHA256
e2335d56d2fd9fc4e3a3f2d3148aafec4962682375f429f05c45a64dacf19436 numpy1.14.1cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
9b762e78739b6e021124adbea07611682db99cd3fca7f3c3a8b98b8f74ea5699 numpy1.14.1cp27cp27mmanylinux1_i686.whl
7d4c549e41507db4f04ec7cfab5597de8acf7871b16c9cf64cebcb9d39031ca6 numpy1.14.1cp27cp27mmanylinux1_x86_64.whl
b803306c4c201e7dcda0ce1b9a9c87f61a7c7ce43de2c60c8e56147b76849a1a numpy1.14.1cp27cp27mumanylinux1_i686.whl
2da8dff91d489fea3e20155d41f4cd680de7d01d9a89fdd0ebb1bee6e72d3800 numpy1.14.1cp27cp27mumanylinux1_x86_64.whl
6b8c2daacbbffc83b4a2ba83a61aa3ce60c66340b07b962bd27b6c6bb175bee1 numpy1.14.1cp27nonewin32.whl
89b9419019c47ec87cf4cfca77d85da4611cc0be636ec87b5290346490b98450 numpy1.14.1cp27nonewin_amd64.whl
49880b47d7272f902946dd995f346842c95fe275e2deb3082ef0495f0c718a69 numpy1.14.1cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
3d7ddd5bdfb12ec9668edf1aa49a4a3eddb0db4661b57ea431477eb9a2468894 numpy1.14.1cp34cp34mmanylinux1_i686.whl
788e1757f8e409cd805a7cd82993cd9252fa19e334758a4c6eb5a8b334abb084 numpy1.14.1cp34cp34mmanylinux1_x86_64.whl
377def0873bbb1fbdedb14b3275b10a29b1b55619a3f7f775c4e7f9ce2461b9c numpy1.14.1cp34nonewin32.whl
9501c9ccd081977ca5579a3ec4009d6baff6bacb04bf07214aade3324734195a numpy1.14.1cp34nonewin_amd64.whl
a1f5173df8190ef9c6235d260d70ca70c6fb029683ceb66e244c5cc6e335947a numpy1.14.1cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
12cf4b27039b88e407ad66894d99a957ef60fea0eeb442026af325add2ab264d numpy1.14.1cp35cp35mmanylinux1_i686.whl
4e2fc841c8c642f7fd44591ef856ca409cedba6aea27928df34004c533839eee numpy1.14.1cp35cp35mmanylinux1_x86_64.whl
e5ade7a69dccbd99c4fdbb95b6d091d941e62ffa588b0ed8fb0a2854118fef3f numpy1.14.1cp35nonewin32.whl
6b1011ffc87d7e2b1b7bcc6dc21bdf177163658746ef778dcd21bf0516b9126c numpy1.14.1cp35nonewin_amd64.whl
a8bc80f69570e11967763636db9b24c1e3e3689881d10ae793cec74cf7a627b6 numpy1.14.1cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
81b9d8f6450e752bd82e7d9618fa053df8db1725747880e76fb09710b57f78d0 numpy1.14.1cp36cp36mmanylinux1_i686.whl
e8522cad377cc2ef20fe13aae742cc265172910c98e8a0d6014b1a8d564019e2 numpy1.14.1cp36cp36mmanylinux1_x86_64.whl
a3d5dd437112292c707e54f47141be2f1100221242f07eda7bd8477f3ddc2252 numpy1.14.1cp36nonewin32.whl
c8000a6cbc5140629be8c038c9c9cdb3a1c85ff90bd4180ec99f0f0c73050b5e numpy1.14.1cp36nonewin_amd64.whl
8708a775be9a9a457b80a49193c57bd9d51a8a195ed1f1c4b8e89eaf3aa646ee numpy1.14.1.tar.gz
fa0944650d5d3fb95869eaacd8eedbd2d83610c85e271bd9d3495ffa9bc4dc9c numpy1.14.1.zip
v1.14.0
charris released this
Assets
==========================
NumPy 1.14.0 Release Notes
Numpy 1.14.0 is the result of seven months of work and contains a large number
of bug fixes and new features, along with several changes with potential
compatibility issues. The major change that users will notice are the
stylistic changes in the way numpy arrays and scalars are printed, a change
that will affect doctests. See below for details on how to preserve the
old style printing when needed.
A major decision affecting future development concerns the schedule for
dropping Python 2.7 support in the runup to 2020. The decision has been made to
support 2.7 for all releases made in 2018, with the last release being
designated a long term release with support for bug fixes extending through
2019. In 2019 support for 2.7 will be dropped in all new releases. More details
can be found in the relevant NEP_.
This release supports Python 2.7 and 3.4  3.6.
.. _NEP: https://github.com/numpy/numpy/blob/master/doc/neps/droppingpython2.7proposal.rst
Highlights

The
np.einsum
function uses BLAS when possible 
genfromtxt
,loadtxt
,fromregex
andsavetxt
can now handle
files with arbitrary Python supported encoding. 
Major improvements to printing of NumPy arrays and scalars.
New functions

parametrize
: decorator added to numpy.testing 
chebinterpolate
: Interpolate function at Chebyshev points. 
format_float_positional
andformat_float_scientific
: format
floatingpoint scalars unambiguously with control of rounding and padding. 
PyArray_ResolveWritebackIfCopy
andPyArray_SetWritebackIfCopyBase
,
new CAPI functions useful in achieving PyPy compatibity.
Deprecations

Using
np.bool_
objects in place of integers is deprecated. Previously
operator.index(np.bool_)
was legal and allowed constructs such as
[1, 2, 3][np.True_]
. That was misleading, as it behaved differently from
np.array([1, 2, 3])[np.True_]
. 
Truth testing of an empty array is deprecated. To check if an array is not
empty, usearray.size > 0
. 
Calling
np.bincount
withminlength=None
is deprecated.
minlength=0
should be used instead. 
Calling
np.fromstring
with the default value of thesep
argument is
deprecated. When that argument is not provided, a broken version of
np.frombuffer
is used that silently accepts unicode strings and  after
encoding them as either utf8 (python 3) or the default encoding
(python 2)  treats them as binary data. If reading binary data is
desired,np.frombuffer
should be used directly. 
The
style
option of array2string is deprecated in nonlegacy printing mode. 
PyArray_SetUpdateIfCopyBase
has been deprecated. For NumPy versions >= 1.14
usePyArray_SetWritebackIfCopyBase
instead, seeC API changes
below for
more details. 
The use of
UPDATEIFCOPY
arrays is deprecated, seeC API changes
below
for details. We will not be dropping support for those arrays, but they are
not compatible with PyPy.
Future Changes

np.issubdtype
will stop downcasting dtypelike arguments.
It might be expected thatissubdtype(np.float32, 'float64')
and
issubdtype(np.float32, np.float64)
mean the same thing  however, there
was an undocumented special case that translated the former into
issubdtype(np.float32, np.floating)
, giving the surprising result of True.This translation now gives a warning that explains what translation is
occurring. In the future, the translation will be disabled, and the first
example will be made equivalent to the second. 
np.linalg.lstsq
default forrcond
will be changed. Thercond
parameter tonp.linalg.lstsq
will change its default to machine precision
times the largest of the input array dimensions. A FutureWarning is issued
whenrcond
is not passed explicitly. 
a.flat.__array__()
will return a writeable copy ofa
whena
is
noncontiguous. Previously it returned an UPDATEIFCOPY array whena
was
writeable. Currently it returns a nonwriteable copy. See gh7054 for a
discussion of the issue. 
Unstructured void array's
.item
method will return a bytes object. In the
future, calling.item()
on arrays or scalars ofnp.void
datatype will
return abytes
object instead of a buffer or int array, the same as
returned bybytes(void_scalar)
. This may affect code which assumed the
return value was mutable, which will no longer be the case. A
FutureWarning
is now issued when this would occur.
Compatibility notes
The mask of a masked array view is also a view rather than a copy
There was a FutureWarning about this change in NumPy 1.11.x. In short, it is
now the case that, when changing a view of a masked array, changes to the mask
are propagated to the original. That was not previously the case. This change
affects slices in particular. Note that this does not yet work properly if the
mask of the original array is nomask
and the mask of the view is changed.
See gh5580 for an extended discussion. The original behavior of having a copy
of the mask can be obtained by calling the unshare_mask
method of the view.
np.ma.masked
is no longer writeable
Attempts to mutate the masked
constant now error, as the underlying arrays
are marked readonly. In the past, it was possible to get away with::
# emulating a function that sometimes returns np.ma.masked
val = random.choice([np.ma.masked, 10])
var_arr = np.asarray(val)
val_arr += 1 # now errors, previously changed np.ma.masked.data
np.ma
functions producing fill_value
s have changed
Previously, np.ma.default_fill_value
would return a 0d array, but
np.ma.minimum_fill_value
and np.ma.maximum_fill_value
would return a
tuple of the fields. Instead, all three methods return a structured np.void
object, which is what you would already find in the .fill_value
attribute.
Additionally, the dtype guessing now matches that of np.array
 so when
passing a python scalar x
, maximum_fill_value(x)
is always the same as
maximum_fill_value(np.array(x))
. Previously x = long(1)
on Python 2
violated this assumption.
a.flat.__array__()
returns nonwriteable arrays when a
is noncontiguous
The intent is that the UPDATEIFCOPY array previously returned when a
was
noncontiguous will be replaced by a writeable copy in the future. This
temporary measure is aimed to notify folks who expect the underlying array be
modified in this situation that that will no longer be the case. The most
likely places for this to be noticed is when expressions of the form
np.asarray(a.flat)
are used, or when a.flat
is passed as the out
parameter to a ufunc.
np.tensordot
now returns zero array when contracting over 0length dimension
Previously np.tensordot
raised a ValueError when contracting over 0length
dimension. Now it returns a zero array, which is consistent with the behaviour
of np.dot
and np.einsum
.
numpy.testing
reorganized
This is not expected to cause problems, but possibly something has been left
out. If you experience an unexpected import problem using numpy.testing
let us know.
np.asfarray
no longer accepts nondtypes through the dtype
argument
This previously would accept dtype=some_array
, with the implied semantics
of dtype=some_array.dtype
. This was undocumented, unique across the numpy
functions, and if used would likely correspond to a typo.
1D np.linalg.norm
preserves float input types, even for arbitrary orders
Previously, this would promote to float64
when arbitrary orders were
passed, despite not doing so under the simple cases::
>>> f32 = np.float32([1, 2])
>>> np.linalg.norm(f32, 2.0).dtype
dtype('float32')
>>> np.linalg.norm(f32, 2.0001).dtype
dtype('float64') # numpy 1.13
dtype('float32') # numpy 1.14
This change affects only float32
and float16
arrays.
count_nonzero(arr, axis=())
now counts over no axes, not all axes
Elsewhere, axis==()
is always understood as "no axes", but
count_nonzero
had a special case to treat this as "all axes". This was
inconsistent and surprising. The correct way to count over all axes has always
been to pass axis == None
.
__init__.py
files added to test directories
This is for pytest compatibility in the case of duplicate test file names in
the different directories. As a result, run_module_suite
no longer works,
i.e., python <pathtotestfile>
results in an error.
.astype(bool)
on unstructured void arrays now calls bool
on each element
On Python 2, void_array.astype(bool)
would always return an array of
True
, unless the dtype is V0
. On Python 3, this operation would usually
crash. Going forwards, astype
matches the behavior of bool(np.void)
,
considering a buffer of all zeros as false, and anything else as true.
Checks for V0
can still be done with arr.dtype.itemsize == 0
.
MaskedArray.squeeze
never returns np.ma.masked
np.squeeze
is documented as returning a view, but the masked variant would
sometimes return masked
, which is not a view. This has been fixed, so that
the result is always a view on the original masked array.
This breaks any code that used masked_arr.squeeze() is np.ma.masked
, but
fixes code that writes to the result of .squeeze()
.
Renamed first parameter of can_cast
from from
to from_
The previous parameter name from
is a reserved keyword in Python, which made
it difficult to pass the argument by name. This has been fixed by renaming
the parameter to from_
.
isnat
raises TypeError
when passed wrong type
The ufunc isnat
used to raise a ValueError
when it was not passed
variables of type datetime
or timedelta
. This has been changed to
raising a TypeError
.
dtype.__getitem__
raises TypeError
when passed wrong type
When indexed with a float, the dtype object used to raise ValueError
.
Userdefined types now need to implement __str__
and __repr__
Previously, userdefined types could fall back to a default implementation of
__str__
and __repr__
implemented in numpy, but this has now been
removed. Now userdefined types will fall back to the python default
object.__str__
and object.__repr__
.
Many changes to array printing, disableable with the new "legacy" printing mode
The str
and repr
of ndarrays and numpy scalars have been changed in
a variety of ways. These changes are likely to break downstream user's
doctests.
These new behaviors can be disabled to mostly reproduce numpy 1.13 behavior by
enabling the new 1.13 "legacy" printing mode. This is enabled by calling
np.set_printoptions(legacy="1.13")
, or using the new legacy
argument to
np.array2string
, as np.array2string(arr, legacy='1.13')
.
In summary, the major changes are:

For floatingpoint types:
 The
repr
of float arrays often omits a space previously printed
in the sign position. See the newsign
option tonp.set_printoptions
.  Floatingpoint arrays and scalars use a new algorithm for decimal
representations, giving the shortest unique representation. This will
usually shortenfloat16
fractional output, and sometimesfloat32
and
float128
output.float64
should be unaffected. See the new
floatmode
option tonp.set_printoptions
.  Float arrays printed in scientific notation no longer use fixedprecision,
and now instead show the shortest unique representation.  The
str
of floatingpoint scalars is no longer truncated in python2.
 The

For other data types:
 Nonfinite complex scalars print like
nanj
instead ofnan*j
. NaT
values in datetime arrays are now properly aligned. Arrays and scalars of
np.void
datatype are now printed using hex
notation.
 Nonfinite complex scalars print like

For linewrapping:
 The "dtype" part of ndarray reprs will now be printed on the next line
if there isn't space on the last line of array output.  The
linewidth
format option is now always respected.
Therepr
orstr
of an array will never exceed this, unless a single
element is too wide.  The last line of an array string will never have more elements than earlier
lines.  An extra space is no longer inserted on the first line if the elements are
too wide.
 The "dtype" part of ndarray reprs will now be printed on the next line

For summarization (the use of
...
to shorten long arrays): A trailing comma is no longer inserted for
str
.
Previously,str(np.arange(1001))
gave
'[ 0 1 2 ..., 998 999 1000]'
, which has an extra comma.  For arrays of 2D and beyond, when
...
is printed on its own line in
order to summarize any but the last axis, newlines are now appended to that
line to match its leading newlines and a trailing space character is
removed.
 A trailing comma is no longer inserted for

MaskedArray
arrays now separate printed elements with commas, always
print the dtype, and correctly wrap the elements of long arrays to multiple
lines. If there is more than 1 dimension, the array attributes are now
printed in a new "leftjustified" printing style. 
recarray
arrays no longer print a trailing space before their dtype, and
wrap to the right number of columns. 
0d arrays no longer have their own idiosyncratic implementations of
str
andrepr
. Thestyle
argument tonp.array2string
is deprecated. 
Arrays of
bool
datatype will omit the datatype in therepr
. 
Userdefined
dtypes
(subclasses ofnp.generic
) now need to
implement__str__
and__repr__
.
Some of these changes are described in more detail below. If you need to retain
the previous behavior for doctests or other reasons, you may want to do
something like::
# FIXME: We need the str/repr formatting used in Numpy < 1.14.
try:
np.set_printoptions(legacy='1.13')
except TypeError:
pass
C API changes
PyPy compatible alternative to UPDATEIFCOPY
arrays
UPDATEIFCOPY
arrays are contiguous copies of existing arrays, possibly with
different dimensions, whose contents are copied back to the original array when
their refcount goes to zero and they are deallocated. Because PyPy does not use
refcounts, they do not function correctly with PyPy. NumPy is in the process of
eliminating their use internally and two new CAPI functions,
PyArray_SetWritebackIfCopyBase
PyArray_ResolveWritebackIfCopy
,
have been added together with a complimentary flag,
NPY_ARRAY_WRITEBACKIFCOPY
. Using the new functionality also requires that
some flags be changed when new arrays are created, to wit:
NPY_ARRAY_INOUT_ARRAY
should be replaced by NPY_ARRAY_INOUT_ARRAY2
and
NPY_ARRAY_INOUT_FARRAY
should be replaced by NPY_ARRAY_INOUT_FARRAY2
.
Arrays created with these new flags will then have the WRITEBACKIFCOPY
semantics.
If PyPy compatibility is not a concern, these new functions can be ignored,
although there will be a DeprecationWarning
. If you do wish to pursue PyPy
compatibility, more information on these functions and their use may be found
in the capi_ documentation and the example in howtoextend_.
.. _capi: https://github.com/numpy/numpy/blob/master/doc/source/reference/capi.array.rst
.. _howtoextend: https://github.com/numpy/numpy/blob/master/doc/source/user/cinfo.howtoextend.rst
New Features
Encoding argument for text IO functions
genfromtxt
, loadtxt
, fromregex
and savetxt
can now handle files
with arbitrary encoding supported by Python via the encoding argument.
For backward compatibility the argument defaults to the special bytes
value
which continues to treat text as raw byte values and continues to pass latin1
encoded bytes to custom converters.
Using any other value (including None
for system default) will switch the
functions to real text IO so one receives unicode strings instead of bytes in
the resulting arrays.
External nose
plugins are usable by numpy.testing.Tester
numpy.testing.Tester
is now aware of nose
plugins that are outside the
nose
builtin ones. This allows using, for example, nosetimer
like
so: np.test(extra_argv=['withtimer', 'timertopn', '20'])
to
obtain the runtime of the 20 slowest tests. An extra keyword timer
was
also added to Tester.test
, so np.test(timer=20)
will also report the 20
slowest tests.
parametrize
decorator added to numpy.testing
A basic parametrize
decorator is now available in numpy.testing
. It is
intended to allow rewriting yield based tests that have been deprecated in
pytest so as to facilitate the transition to pytest in the future. The nose
testing framework has not been supported for several years and looks like
abandonware.
The new parametrize
decorator does not have the full functionality of the
one in pytest. It doesn't work for classes, doesn't support nesting, and does
not substitute variable names. Even so, it should be adequate to rewrite the
NumPy tests.
chebinterpolate
function added to numpy.polynomial.chebyshev
The new chebinterpolate
function interpolates a given function at the
Chebyshev points of the first kind. A new Chebyshev.interpolate
class
method adds support for interpolation over arbitrary intervals using the scaled
and shifted Chebyshev points of the first kind.
Support for reading lzma compressed text files in Python 3
With Python versions containing the lzma
module the text IO functions can
now transparently read from files with xz
or lzma
extension.
sign
option added to np.setprintoptions
and np.array2string
This option controls printing of the sign of floatingpoint types, and may be
one of the characters '', '+' or ' '. With '+' numpy always prints the sign of
positive values, with ' ' it always prints a space (whitespace character) in
the sign position of positive values, and with '' it will omit the sign
character for positive values. The new default is ''.
This new default changes the float output relative to numpy 1.13. The old
behavior can be obtained in 1.13 "legacy" printing mode, see compatibility
notes above.
hermitian
option added tonp.linalg.matrix_rank
The new hermitian
option allows choosing between standard SVD based matrix
rank calculation and the more efficient eigenvalue based method for
symmetric/hermitian matrices.
threshold
and edgeitems
options added to np.array2string
These options could previously be controlled using np.set_printoptions
, but
now can be changed on a percall basis as arguments to np.array2string
.
concatenate
and stack
gained an out
argument
A preallocated buffer of the desired dtype can now be used for the output of
these functions.
Support for PGI flang compiler on Windows
The PGI flang compiler is a Fortran front end for LLVM released by NVIDIA under
the Apache 2 license. It can be invoked by ::
python setup.py config compiler=clang fcompiler=flang install
There is little experience with this new compiler, so any feedback from people
using it will be appreciated.
Improvements
Numerator degrees of freedom in random.noncentral_f
need only be positive.
Prior to NumPy 1.14.0, the numerator degrees of freedom needed to be > 1, but
the distribution is valid for values > 0, which is the new requirement.
The GIL is released for all np.einsum
variations
Some specific loop structures which have an accelerated loop version
did not release the GIL prior to NumPy 1.14.0. This oversight has been
fixed.
The np.einsum
function will use BLAS when possible and optimize by default
The np.einsum
function will now call np.tensordot
when appropriate.
Because np.tensordot
uses BLAS when possible, that will speed up execution.
By default, np.einsum
will also attempt optimization as the overhead is
small relative to the potential improvement in speed.
f2py
now handles arrays of dimension 0
f2py
now allows for the allocation of arrays of dimension 0. This allows
for more consistent handling of corner cases downstream.
numpy.distutils
supports using MSVC and mingw64gfortran together
Numpy distutils now supports using Mingw64 gfortran and MSVC compilers
together. This enables the production of Python extension modules on Windows
containing Fortran code while retaining compatibility with the
binaries distributed by Python.org. Not all use cases are supported,
but most common ways to wrap Fortran for Python are functional.
Compilation in this mode is usually enabled automatically, and can be
selected via the fcompiler
and compiler
options to
setup.py
. Moreover, linking Fortran codes to static OpenBLAS is
supported; by default a gfortran compatible static archive
openblas.a
is looked for.
np.linalg.pinv
now works on stacked matrices
Previously it was limited to a single 2d array.
numpy.save
aligns data to 64 bytes instead of 16
Saving NumPy arrays in the npy
format with numpy.save
inserts
padding before the array data to align it at 64 bytes. Previously
this was only 16 bytes (and sometimes less due to a bug in the code
for version 2). Now the alignment is 64 bytes, which matches the
widest SIMD instruction set commonly available, and is also the most
common cache line size. This makes npy
files easier to use in
programs which open them with mmap
, especially on Linux where an
mmap
offset must be a multiple of the page size.
NPZ files now can be written without using temporary files
In Python 3.6+ numpy.savez
and numpy.savez_compressed
now write
directly to a ZIP file, without creating intermediate temporary files.
Better support for empty structured and string types
Structured types can contain zero fields, and string dtypes can contain zero
characters. Zerolength strings still cannot be created directly, and must be
constructed through structured dtypes::
str0 = np.empty(10, np.dtype([('v', str, N)]))['v']
void0 = np.empty(10, np.void)
It was always possible to work with these, but the following operations are
now supported for these arrays:
arr.sort()
arr.view(bytes)
arr.resize(...)
pickle.dumps(arr)
Support for decimal.Decimal
in np.lib.financial
Unless otherwise stated all functions within the financial
package now
support using the decimal.Decimal
builtin type.
Float printing now uses "dragon4" algorithm for shortest decimal representation
The str
and repr
of floatingpoint values (16, 32, 64 and 128 bit) are
now printed to give the shortest decimal representation which uniquely
identifies the value from others of the same type. Previously this was only
true for float64
values. The remaining float types will now often be shorter
than in numpy 1.13. Arrays printed in scientific notation now also use the
shortest scientific representation, instead of fixed precision as before.
Additionally, the str
of float scalars scalars will no longer be truncated
in python2, unlike python2 float
s. np.double
scalars now have a str
and repr
identical to that of a python3 float.
New functions np.format_float_scientific
and np.format_float_positional
are provided to generate these decimal representations.
A new option floatmode
has been added to np.set_printoptions
and
np.array2string
, which gives control over uniqueness and rounding of
printed elements in an array. The new default is floatmode='maxprec'
with
precision=8
, which will print at most 8 fractional digits, or fewer if an
element can be uniquely represented with fewer. A useful new mode is
floatmode="unique"
, which will output enough digits to specify the array
elements uniquely.
Numpy complexfloatingscalars with values like inf*j
or nan*j
now
print as infj
and nanj
, like the purepython complex
type.
The FloatFormat
and LongFloatFormat
classes are deprecated and should
both be replaced by FloatingFormat
. Similarly ComplexFormat
and
LongComplexFormat
should be replaced by ComplexFloatingFormat
.
void
datatype elements are now printed in hex notation
A hex representation compatible with the python bytes
type is now printed
for unstructured np.void
elements, e.g., V4
datatype. Previously, in
python2 the raw void data of the element was printed to stdout, or in python3
the integer byte values were shown.
printing style for void
datatypes is now independently customizable
The printing style of np.void
arrays is now independently customizable
using the formatter
argument to np.set_printoptions
, using the
'void'
key, instead of the catchall numpystr
key as before.
Reduced memory usage of np.loadtxt
np.loadtxt
now reads files in chunks instead of all at once which decreases
its memory usage significantly for large files.
Changes
Multiplefield indexing/assignment of structured arrays
The indexing and assignment of structured arrays with multiple fields has
changed in a number of ways, as warned about in previous releases.
First, 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 have extra padding bytes corresponding to
intervening fields in the original array, unlike the copy in 1.13, which will
affect code such as arr[['f1', 'f3']].view(newdtype)
.
Second, assignment between structured arrays will now occur "by position"
instead of "by field name". The Nth field of the destination will be set to the
Nth field of the source regardless of field name, unlike in numpy versions 1.6
to 1.13 in which fields in the destination array were set to the
identicallynamed field in the source array or to 0 if the source did not have
a field.
Correspondingly, the order of fields in a structured dtypes now matters when
computing dtype equality. For example, with the dtypes ::
x = dtype({'names': ['A', 'B'], 'formats': ['i4', 'f4'], 'offsets': [0, 4]})
y = dtype({'names': ['B', 'A'], 'formats': ['f4', 'i4'], 'offsets': [4, 0]})
the expression x == y
will now return False
, unlike before.
This makes dictionary based dtype specifications like
dtype({'a': ('i4', 0), 'b': ('f4', 4)})
dangerous in python < 3.6
since dict key order is not preserved in those versions.
Assignment from a structured array to a boolean array now raises a ValueError,
unlike in 1.13, where it always set the destination elements to True
.
Assignment from structured array with more than one field to a nonstructured
array now raises a ValueError. In 1.13 this copied just the first field of the
source to the destination.
Using field "titles" in multiplefield indexing is now disallowed, as is
repeating a field name in a multiplefield index.
The documentation for structured arrays in the user guide has been
significantly updated to reflect these changes.
Integer and Void scalars are now unaffected by np.set_string_function
Previously, unlike most other numpy scalars, the str
and repr
of
integer and void scalars could be controlled by np.set_string_function
.
This is no longer possible.
0d array printing changed, style
arg of array2string deprecated
Previously the str
and repr
of 0d arrays had idiosyncratic
implementations which returned str(a.item())
and 'array(' + repr(a.item()) + ')'
respectively for 0d array a
, unlike both numpy
scalars and higher dimension ndarrays.
Now, the str
of a 0d array acts like a numpy scalar using str(a[()])
and the repr
acts like higher dimension arrays using formatter(a[()])
,
where formatter
can be specified using np.set_printoptions
. The
style
argument of np.array2string
is deprecated.
This new behavior is disabled in 1.13 legacy printing mode, see compatibility
notes above.
Seeding RandomState
using an array requires a 1d array
RandomState
previously would accept empty arrays or arrays with 2 or more
dimensions, which resulted in either a failure to seed (empty arrays) or for
some of the passed values to be ignored when setting the seed.
MaskedArray
objects show a more useful repr
The repr
of a MaskedArray
is now closer to the python code that would
produce it, with arrays now being shown with commas and dtypes. Like the other
formatting changes, this can be disabled with the 1.13 legacy printing mode in
order to help transition doctests.
The repr
of np.polynomial
classes is more explicit
It now shows the domain and window parameters as keyword arguments to make
them more clear::
>>> np.polynomial.Polynomial(range(4))
Polynomial([0., 1., 2., 3.], domain=[1, 1], window=[1, 1])
Checksums
MD5
dddfd1effddd4b73120bfa0f31a27f30 numpy1.14.0cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ab7e3518c7fe2a0d8e3c1e90c32ab57b numpy1.14.0cp27cp27mmanylinux1_i686.whl
8ba61f88afea560cc93ffddc9ea717d8 numpy1.14.0cp27cp27mmanylinux1_x86_64.whl
edea7b57d4d924173c9c6d8125affe4e numpy1.14.0cp27cp27mumanylinux1_i686.whl
bb048ccc49572e5e661ec7ead183272d numpy1.14.0cp27cp27mumanylinux1_x86_64.whl
23248896d89fd09ef06aecbdc1e74eb7 numpy1.14.0cp27nonewin32.whl
09bef789f8d9352cafe98a6773c53f3a numpy1.14.0cp27nonewin_amd64.whl
8bc2cc282df9597fe4c5fda72d0ff851 numpy1.14.0cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c9ce8e4de0293585ad8455a829cdbdff numpy1.14.0cp34cp34mmanylinux1_i686.whl
8179996e99adfbe7c66c5a9f7ad37139 numpy1.14.0cp34cp34mmanylinux1_x86_64.whl
bf839d99514ecc03da1a2dc42808c1c7 numpy1.14.0cp34nonewin32.whl
80ead56627e40a00d0832793f5798ce8 numpy1.14.0cp34nonewin_amd64.whl
1a58fbaea199e425b71b3bfb1276d957 numpy1.14.0cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
00cbdb6d9aa1eca97ecdb73a2705730b numpy1.14.0cp35cp35mmanylinux1_i686.whl
47de646ff0d4591431030ee93412f9f3 numpy1.14.0cp35cp35mmanylinux1_x86_64.whl
f42aab8c9d6a21f60b051d6ea0b33425 numpy1.14.0cp35nonewin32.whl
b6d917bb34760e0f659c671efc08c602 numpy1.14.0cp35nonewin_amd64.whl
5a6456f4471b2f7d03fec5759e929544 numpy1.14.0cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
3c72836ee01e7b88d7cebee0a1c94c6e numpy1.14.0cp36cp36mmanylinux1_i686.whl
34f763b99cc39ca3224c158ec82e2b39 numpy1.14.0cp36cp36mmanylinux1_x86_64.whl
3bee8e2e4414a9df909d6510bd803aa1 numpy1.14.0cp36nonewin32.whl
f3db47f66b406f2803b681051f452f6e numpy1.14.0cp36nonewin_amd64.whl
c573e2d2f26a5786d5198a660f87d8e4 numpy1.14.0.tar.gz
c12d4bf380ac925fcdc8a59ada6c3298 numpy1.14.0.zip
SHA256
428cd3c0b197cf857671353d8c85833193921af9fafcc169a1f29c7185833d50 numpy1.14.0cp27cp27mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
a476e437d73e5754aa66e1e75840d0163119c3911b7361f4cd06985212a3c3fb numpy1.14.0cp27cp27mmanylinux1_i686.whl
289ff717138cd9aa133adcbd3c3e284458b9c8230db4d42b39083a3407370317 numpy1.14.0cp27cp27mmanylinux1_x86_64.whl
c5eccb4bf96dbb2436c61bb3c2658139e779679b6ae0d04c5e268e6608b58053 numpy1.14.0cp27cp27mumanylinux1_i686.whl
75471acf298d455b035226cc609a92aee42c4bb6aa71def85f77fa2c2b646b61 numpy1.14.0cp27cp27mumanylinux1_x86_64.whl
5c54fb98ecf42da59ed93736d1c071842482b18657eb16ba6e466bd873e1b923 numpy1.14.0cp27nonewin32.whl
9ddf384ac3aacb72e122a8207775cc29727cbd9c531ee1a4b95754f24f42f7f3 numpy1.14.0cp27nonewin_amd64.whl
781d3197da49c421a07f250750de70a52c42af08ca02a2f7bdb571c0625ae7eb numpy1.14.0cp34cp34mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
93b26d6c06a22e64d56aaca32aaaffd27a4143db0ac2f21a048f0b571f2bfc55 numpy1.14.0cp34cp34mmanylinux1_i686.whl
b2547f57d05ba59df4289493254f29f4c9082d255f1f97b7e286f40f453e33a1 numpy1.14.0cp34cp34mmanylinux1_x86_64.whl
eef6af1c752eef538a96018ef9bdf8e37bbf28aab50a1436501a4aa47a6467df numpy1.14.0cp34nonewin32.whl
ff8a4b2c3ac831964f529a2da506c28d002562b230261ae5c16885f5f53d2e75 numpy1.14.0cp34nonewin_amd64.whl
194074058c22a4066e1b6a4ea432486ee468d24ab16f13630c1030409e6b8666 numpy1.14.0cp35cp35mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
4e13f1a848fde960dea33702770265837c72b796a6a3eaac7528cfe75ddefadd numpy1.14.0cp35cp35mmanylinux1_i686.whl
91101216d72749df63968d86611b549438fb18af2c63849c01f9a897516133c7 numpy1.14.0cp35cp35mmanylinux1_x86_64.whl
97507349abb7d1f6b76b877258defe8720833881dc7e7fd052bac90c88587387 numpy1.14.0cp35nonewin32.whl
1479b46b6040b5c689831496354c8859c456b152d37315673a0c18720b41223b numpy1.14.0cp35nonewin_amd64.whl
98b1ac79c160e36093d7914244e40ee1e7164223e795aa2c71dcce367554e646 numpy1.14.0cp36cp36mmacosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
24bbec9a199f938eab75de8390f410969bc33c218e5430fa1ae9401b00865255 numpy1.14.0cp36cp36mmanylinux1_i686.whl
7880f412543e96548374a4bb1d75e4cdb8cad80f3a101ed0f8d0e0428f719c1c numpy1.14.0cp36cp36mmanylinux1_x86_64.whl
6112f152b76a28c450bbf665da11757078a724a90330112f5b7ea2d6b6cefd67 numpy1.14.0cp36nonewin32.whl
7c5276763646480143d5f3a6c2acb2885460c765051a1baf4d5070f63d05010f numpy1.14.0cp36nonewin_amd64.whl
c45d99134bb07600e916537c51c22e87f9e0c44b05d71018ab4907e195f007ce numpy1.14.0.tar.gz
3de643935b212307b420248018323a44ec51987a336d1d747c1322afc3c099fb numpy1.14.0.zip
Watchers：439 
Star：9261 
Fork：3245 
创建时间： 20100914 07:02:39 
最后Commits： 前天 
许可协议：View license 
971e2e8
Verified
charris released this
Jan 14, 2019
· 217 commits to master since this release
==========================
NumPy 1.16.0 Release Notes
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.53.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 support for overriding numpy functions,
see
__array_function__
below.The
matmul
function is now a ufunc. This provides betterperformance 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 thestructured 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
andnumpy.core.sctypeNA
aredeprecated. 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 morepowerful
numpy.ndarray.item
, not tested, and fails for scalars.The
numpy.set_array_ops
andnumpy.get_array_ops
functions are deprecated.As part of
NEP 15
, they have been deprecated along with the CAPI functions:c:func:
PyArray_SetNumericOps
and :c:func:PyArray_GetNumericOps
. Userswho wish to override the inner loop functions in builtin ufuncs should use
:c:func:
PyUFunc_ReplaceLoopBySignature
.The
numpy.unravel_index
keyword argumentdims
is deprecated, useshape
instead.The
numpy.histogram
normed
argument is deprecated. It was deprecatedpreviously, but no warning was issued.
The
positive
operator (+
) applied to nonnumerical arrays isdeprecated. See below for details.
Passing an iterator to the stack functions is deprecated
Expired deprecations
NaT comparisons now return
False
without a warning, finishing adeprecation cycle begun in NumPy 1.11.
np.lib.function_base.unique
was removed, finishing a deprecation cyclebegun in NumPy 1.4. Use
numpy.unique
instead.multifield 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
andnp.pkgload
have been removed. These weredeprecated in 1.10, had no tests, and seem to no longer work in 1.15.
Future changes
Compatibility notes
f2py script on Windows
On Windows, the installed script for running f2py is now an
.exe
filerather than a
*.py
file and should be run from the command line asf2py
whenever the
Scripts
directory is in the path. Runningf2py
as a modulepython m numpy.f2py [...]
will work without path modification in anyversion of NumPy.
NaT comparisons
Consistent with the behavior of NaN, all comparisons other than inequality
checks with datetime64 or timedelta64 NaT ("notatime") values now always
return
False
, and inequality checks with NaT now always returnTrue
.This includes comparisons beteween NaT values. For compatibility with the
old behavior, use
np.isnat
to explicitly check for NaT or convertdatetime64/timedelta64 arrays with
.astype(np.int64)
before makingcomparisons.
complex64/128 alignment has changed
The memory alignment of complex types is now the same as a Cstruct 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
4byte aligned instead of 8byte 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 Cstruct
struct {float r, i;}
, according to the compiler used to compile numpy, andsimilarly for the complex128 and complex256 types.
nd_grid len removal
len(np.mgrid)
andlen(np.ogrid)
are now considered nonsensicaland raise a
TypeError
.np.unravel_index
now acceptsshape
keyword argumentPreviously, only the
dims
keyword argument was acceptedfor specification of the shape of the array to be used
for unraveling.
dims
remains supported, but is now deprecated.multifield 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 numpy1.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 whichsafely 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.html#accessingmultiplefields>
__.C API changes
The :c:data:
NPY_API_VERSION
was incremented to 0x0000D, due to the additionof:
PyUFuncObject.core_dim_flags
PyUFuncObject.core_dim_sizes
PyUFuncObject.identity_value
PyUFunc_FromFuncAndDataAndSignatureAndIdentity
New Features
Integrated squared error (ISE) estimator added to
histogram
This method (
bins='stone'
) for optimizing the bin number is ageneralization of the Scott's rule. The Scott's rule assumes the distribution
is approximately Normal, while the ISE_ is a nonparametric method based on
crossvalidation.
.. _ISE: https://en.wikipedia.org/wiki/Histogram#Minimizing_crossvalidation_estimated_squared_error
max_rows
keyword added fornp.loadtxt
New keyword
max_rows
innumpy.loadtxt
sets the maximum rows of thecontent to be read after
skiprows
, as innumpy.genfromtxt
.modulus operator support added for
np.timedelta64
operandsThe modulus (remainder) operator is now supported for two operands
of type
np.timedelta64
. The operands may have different unitsand the return value will match the type of the operands.
Improvements
nocopy 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, alarge variety of numpy arrays can now be serialized without any copy using
outofband buffers, and with one less copy using inband 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 withsubprocess.check_output
where appropriate.np.polynomial.Polynomial
classes render in LaTeX in Jupyter notebooksWhen used in a frontend that supports it,
Polynomial
instances are nowrendered through LaTeX. The current format is experimental, and is subject to
change.
randint
andchoice
now work on empty distributionsEven when no elements needed to be drawn,
np.random.randint
andnp.random.choice
raised an error when the arguments described an emptydistribution. This has been fixed so that e.g.
np.random.choice([], 0) == np.array([], dtype=float64)
.linalg.lstsq
,linalg.qr
, andlinalg.svd
now work with empty arraysPreviously, a
LinAlgError
would be raised when an empty matrix/emptymatrices (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
andnumpy.expand_dims
now work onndarray
subclassesIn particular, they now work for masked arrays.
NPY_NO_DEPRECATED_API
compiler warning suppressionSetting
NPY_NO_DEPRECATED_API
to a value of 0 will suppress the current compilerwarnings when the deprecated numpy API is used.
np.diff
Added kwargs prepend and appendNew kwargs
prepend
andappend
, allow for values to be inserted oneither end of the differences. Similar to options for
ediff1d
. Now theinverse of
cumsum
can be obtained easily viaprepend=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 toLDFLAGS
andother similar such environment variables for compiling Fortran extensions.
Now, if the
NPY_DISTUTILS_APPEND_FLAGS
environment variable is set to 1, thebehavior will be appending. This applied to:
LDFLAGS
,F77FLAGS
,F90FLAGS
,FREEFLAGS
,FOPT
,FDEBUG
, andFFLAGS
. See gh11525 for moredetails.
Generalized ufunc signatures now allow fixedsize 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 twodimensional cartesian unit vector would be
()>(2)
; thatfor one that converts two spherical angles to a threedimensional unit vector
would be
(),()>(3)
; and that for the cross product of twothreedimensional 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
@
asmatmul
,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 operandhas 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 thecorresponding core shape of
(m, 1)
. The actual output array, however, hasthe 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 elementaryfunction, and the output as
(1, 1)
, while the actual output array returnedwill have shape
()
. In this way, the signature allows one to use asingle 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 theclip
method check for memory overlapThe
out
argument to these functions is now always tested for memory overlapto avoid corrupted results when memory overlap occurs.
New value
unscaled
for optioncov
innp.polyfit
A further possible value has been added to the
cov
parameter of thenp.polyfit
function. Withcov='unscaled'
the scaling of the covariancematrix is disabled completely (similar to setting
absolute_sigma=True
inscipy.optimize.curve_fit
). This would be useful in occasions, where theweights 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 asnumpy.intc
,numpy.int_
, andnumpy.longlong
, now lists all of the aliased names for thattype, distinguishing between platform dependent and independent aliases.
__module__
attribute now points to public modulesThe
__module__
attribute on most NumPy functions has been updated to referto 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 leastmadvise
.Systems which already have it set to
always
will not see much difference asthe 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 toalways
to avoidperformance 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 nonglibc
distrubutions like Alpine Linux as long as they ship
fenv.h
.Speedup
np.block
for large arraysLarge arrays (greater than
512 * 512
) now use a blocking algorithm based oncopying 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