==========================
This NumPy release is the last one to support Python 2.7 and will be maintained
as a long term release with bug fixes until 2020. Support for Python 3.4 been
dropped, the supported Python versions are 2.7 and 3.5-3.7. The wheels on PyPI
are linked with OpenBLAS v0.3.4+, which should fix the known threading issues
found in previous OpenBLAS versions.
Downstream developers building this release should use Cython >= 0.29 and, if
using OpenBLAS, OpenBLAS > v0.3.4.
This release has seen a lot of refactoring and features many bug fixes, improved
code organization, and better cross platform compatibility. Not all of these
improvements will be visible to users, but they should help make maintenance
easier going forward.
Highlights
==========
* Experimental support for overriding numpy functions,
see ``__array_function__`` below.
* The ``matmul`` function is now a ufunc. This provides better
performance and allows overriding with ``__array_ufunc__``.
* Improved support for the ARM and POWER architectures.
* Improved support for AIX and PyPy.
* Improved interop with ctypes.
* Improved support for PEP 3118.
New functions
=============
* New functions added to the `numpy.lib.recfuntions` module to ease the
structured assignment changes:
* ``assign_fields_by_name``
* ``structured_to_unstructured``
* ``unstructured_to_structured``
* ``apply_along_fields``
* ``require_fields``
See the user guide at <https://docs.scipy.org/doc/numpy/user/basics.rec.html>
for more info.
New deprecations
================
* The type dictionaries `numpy.core.typeNA` and `numpy.core.sctypeNA` are
deprecated. They were buggy and not documented and will be removed in the
1.18 release. Use`numpy.sctypeDict` instead.
* The `numpy.asscalar` function is deprecated. It is an alias to the more
powerful `numpy.ndarray.item`, not tested, and fails for scalars.
* The `numpy.set_array_ops` and `numpy.get_array_ops` functions are deprecated.
As part of `NEP 15`, they have been deprecated along with the C-API functions
:c:func:`PyArray_SetNumericOps` and :c:func:`PyArray_GetNumericOps`. Users
who wish to override the inner loop functions in built-in ufuncs should use
:c:func:`PyUFunc_ReplaceLoopBySignature`.
* The `numpy.unravel_index` keyword argument ``dims`` is deprecated, use
``shape`` instead.
* The `numpy.histogram` ``normed`` argument is deprecated. It was deprecated
previously, but no warning was issued.
* The ``positive`` operator (``+``) applied to non-numerical arrays is
deprecated. See below for details.
* Passing an iterator to the stack functions is deprecated
Expired deprecations
====================
* NaT comparisons now return ``False`` without a warning, finishing a
deprecation cycle begun in NumPy 1.11.
* ``np.lib.function_base.unique`` was removed, finishing a deprecation cycle
begun in NumPy 1.4. Use `numpy.unique` instead.
* multi-field indexing now returns views instead of copies, finishing a
deprecation cycle begun in NumPy 1.7. The change was previously attempted in
NumPy 1.14 but reverted until now.
* ``np.PackageLoader`` and ``np.pkgload`` have been removed. These were
deprecated in 1.10, had no tests, and seem to no longer work in 1.15.
Future changes
==============
* NumPy 1.17 will drop support for Python 2.7.
Compatibility notes
===================
f2py script on Windows
----------------------
On Windows, the installed script for running f2py is now an ``.exe`` file
rather than a ``*.py`` file and should be run from the command line as ``f2py``
whenever the ``Scripts`` directory is in the path. Running ``f2py`` as a module
``python -m numpy.f2py [...]`` will work without path modification in any
version of NumPy.
NaT comparisons
---------------
Consistent with the behavior of NaN, all comparisons other than inequality
checks with datetime64 or timedelta64 NaT ("not-a-time") values now always
return ``False``, and inequality checks with NaT now always return ``True``.
This includes comparisons beteween NaT values. For compatibility with the
old behavior, use ``np.isnat`` to explicitly check for NaT or convert
datetime64/timedelta64 arrays with ``.astype(np.int64)`` before making
comparisons.
complex64/128 alignment has changed
-----------------------------------
The memory alignment of complex types is now the same as a C-struct composed of
two floating point values, while before it was equal to the size of the type.
For many users (for instance on x64/unix/gcc) this means that complex64 is now
4-byte aligned instead of 8-byte aligned. An important consequence is that
aligned structured dtypes may now have a different size. For instance,
``np.dtype('c8,u1', align=True)`` used to have an itemsize of 16 (on x64/gcc)
but now it is 12.
More in detail, the complex64 type now has the same alignment as a C-struct
``struct {float r, i;}``, according to the compiler used to compile numpy, and
similarly for the complex128 and complex256 types.
nd_grid __len__ removal
-----------------------
``len(np.mgrid)`` and ``len(np.ogrid)`` are now considered nonsensical
and raise a ``TypeError``.
``np.unravel_index`` now accepts ``shape`` keyword argument
-----------------------------------------------------------
Previously, only the ``dims`` keyword argument was accepted
for specification of the shape of the array to be used
for unraveling. ``dims`` remains supported, but is now deprecated.
multi-field views return a view instead of a copy
-------------------------------------------------
Indexing a structured array with multiple fields, e.g., ``arr[['f1', 'f3']]``,
returns a view into the original array instead of a copy. The returned view
will often have extra padding bytes corresponding to intervening fields in the
original array, unlike before, which will affect code such as
``arr[['f1', 'f3']].view('float64')``. This change has been planned since numpy
1.7. Operations hitting this path have emitted ``FutureWarnings`` since then.
Additional ``FutureWarnings`` about this change were added in 1.12.
To help users update their code to account for these changes, a number of
functions have been added to the ``numpy.lib.recfunctions`` module which
safely allow such operations. For instance, the code above can be replaced
with ``structured_to_unstructured(arr[['f1', 'f3']], dtype='float64')``.
See the "accessing multiple fields" section of the
`user guide <https://docs.scipy.org/doc/numpy/user/basics.rec.html#accessing-multiple-fields>`__.
C API changes
=============
The :c:data:`NPY_API_VERSION` was incremented to 0x0000D, due to the addition
of:
* :c:member:`PyUFuncObject.core_dim_flags`
* :c:member:`PyUFuncObject.core_dim_sizes`
* :c:member:`PyUFuncObject.identity_value`
* :c:function:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity`
New Features
============
Integrated squared error (ISE) estimator added to ``histogram``
---------------------------------------------------------------
This method (``bins='stone'``) for optimizing the bin number is a
generalization of the Scott's rule. The Scott's rule assumes the distribution
is approximately Normal, while the ISE_ is a non-parametric method based on
cross-validation.
.. _ISE: https://en.wikipedia.org/wiki/Histogram#Minimizing_cross-validation_estimated_squared_error
``max_rows`` keyword added for ``np.loadtxt``
---------------------------------------------
New keyword ``max_rows`` in `numpy.loadtxt` sets the maximum rows of the
content to be read after ``skiprows``, as in `numpy.genfromtxt`.
modulus operator support added for ``np.timedelta64`` operands
--------------------------------------------------------------
The modulus (remainder) operator is now supported for two operands
of type ``np.timedelta64``. The operands may have different units
and the return value will match the type of the operands.
Improvements
============
no-copy pickling of numpy arrays
--------------------------------
Up to protocol 4, numpy array pickling created 2 spurious copies of the data
being serialized. With pickle protocol 5, and the ``PickleBuffer`` API, a
large variety of numpy arrays can now be serialized without any copy using
out-of-band buffers, and with one less copy using in-band buffers. This
results, for large arrays, in an up to 66% drop in peak memory usage.
build shell independence
------------------------
NumPy builds should no longer interact with the host machine
shell directly. ``exec_command`` has been replaced with
``subprocess.check_output`` where appropriate.
`np.polynomial.Polynomial` classes render in LaTeX in Jupyter notebooks
-----------------------------------------------------------------------
When used in a front-end that supports it, `Polynomial` instances are now
rendered through LaTeX. The current format is experimental, and is subject to
change.
``randint`` and ``choice`` now work on empty distributions
----------------------------------------------------------
Even when no elements needed to be drawn, ``np.random.randint`` and
``np.random.choice`` raised an error when the arguments described an empty
distribution. This has been fixed so that e.g.
``np.random.choice([], 0) == np.array([], dtype=float64)``.
``linalg.lstsq``, ``linalg.qr``, and ``linalg.svd`` now work with empty arrays
------------------------------------------------------------------------------
Previously, a ``LinAlgError`` would be raised when an empty matrix/empty
matrices (with zero rows and/or columns) is/are passed in. Now outputs of
appropriate shapes are returned.
Chain exceptions to give better error messages for invalid PEP3118 format strings
---------------------------------------------------------------------------------
This should help track down problems.
Einsum optimization path updates and efficiency improvements
------------------------------------------------------------
Einsum was synchronized with the current upstream work.
`numpy.angle` and `numpy.expand_dims` now work on ``ndarray`` subclasses
------------------------------------------------------------------------
In particular, they now work for masked arrays.
``NPY_NO_DEPRECATED_API`` compiler warning suppression
------------------------------------------------------
Setting ``NPY_NO_DEPRECATED_API`` to a value of 0 will suppress the current compiler
warnings when the deprecated numpy API is used.
``np.diff`` Added kwargs prepend and append
-------------------------------------------
New kwargs ``prepend`` and ``append``, allow for values to be inserted on
either end of the differences. Similar to options for `ediff1d`. Now the
inverse of `cumsum` can be obtained easily via ``prepend=0``.
ARM support updated
-------------------
Support for ARM CPUs has been updated to accommodate 32 and 64 bit targets,
and also big and little endian byte ordering. AARCH32 memory alignment issues
have been addressed. CI testing has been expanded to include AARCH64 targets
via the services of shippable.com.
Appending to build flags
------------------------
`numpy.distutils` has always overridden rather than appended to `LDFLAGS` and
other similar such environment variables for compiling Fortran extensions.
Now, if the `NPY_DISTUTILS_APPEND_FLAGS` environment variable is set to 1, the
behavior will be appending. This applied to: `LDFLAGS`, `F77FLAGS`,
`F90FLAGS`, `FREEFLAGS`, `FOPT`, `FDEBUG`, and `FFLAGS`. See gh-11525 for more
details.
Generalized ufunc signatures now allow fixed-size dimensions
------------------------------------------------------------
By using a numerical value in the signature of a generalized ufunc, one can
indicate that the given function requires input or output to have dimensions
with the given size. E.g., the signature of a function that converts a polar
angle to a two-dimensional cartesian unit vector would be ``()->(2)``; that
for one that converts two spherical angles to a three-dimensional unit vector
would be ``(),()->(3)``; and that for the cross product of two
three-dimensional vectors would be ``(3),(3)->(3)``.
Note that to the elementary function these dimensions are not treated any
differently from variable ones indicated with a name starting with a letter;
the loop still is passed the corresponding size, but it can now count on that
size being equal to the fixed one given in the signature.
Generalized ufunc signatures now allow flexible dimensions
----------------------------------------------------------
Some functions, in particular numpy's implementation of ` as ``matmul``,
are very similar to generalized ufuncs in that they operate over core
dimensions, but one could not present them as such because they were able to
deal with inputs in which a dimension is missing. To support this, it is now
allowed to postfix a dimension name with a question mark to indicate that the
dimension does not necessarily have to be present.
With this addition, the signature for ``matmul`` can be expressed as
``(m?,n),(n,p?)->(m?,p?)``. This indicates that if, e.g., the second operand
has only one dimension, for the purposes of the elementary function it will be
treated as if that input has core shape ``(n, 1)``, and the output has the
corresponding core shape of ``(m, 1)``. The actual output array, however, has
the flexible dimension removed, i.e., it will have shape ``(..., m)``.
Similarly, if both arguments have only a single dimension, the inputs will be
presented as having shapes ``(1, n)`` and ``(n, 1)`` to the elementary
function, and the output as ``(1, 1)``, while the actual output array returned
will have shape ``()``. In this way, the signature allows one to use a
single elementary function for four related but different signatures,
``(m,n),(n,p)->(m,p)``, ``(n),(n,p)->(p)``, ``(m,n),(n)->(m)`` and
``(n),(n)->()``.
``np.clip`` and the ``clip`` method check for memory overlap
------------------------------------------------------------
The ``out`` argument to these functions is now always tested for memory overlap
to avoid corrupted results when memory overlap occurs.
New value ``unscaled`` for option ``cov`` in ``np.polyfit''
-----------------------------------------------------------
A further possible value has been added to the ``cov`` parameter of the
``np.polyfit`` function. With ``cov='unscaled'`` the scaling of the covariance
matrix is disabled completely (similar to setting ``absolute_sigma=True'' in
``scipy.optimize.curve_fit``). This would be useful in occasions, where the
weights are given by 1/sigma with sigma being the (known) standard errors of
(Gaussian distributed) data points, in which case the unscaled matrix is
already a correct estimate for the covariance matrix.
Detailed docstrings for scalar numeric types
--------------------------------------------
The ``help`` function, when applied to numeric types such as `numpy.intc`,
`numpy.int_`, and `numpy.longlong`, now lists all of the aliased names for that
type, distinguishing between platform -dependent and -independent aliases.
``__module__`` attribute now points to public modules
-----------------------------------------------------
The ``__module__`` attribute on most NumPy functions has been updated to refer
to the preferred public module from which to access a function, rather than
the module in which the function happens to be defined. This produces more
informative displays for functions in tools such as IPython, e.g., instead of
``<function 'numpy.core.fromnumeric.sum'>`` you now see
``<function 'numpy.sum'>``.
Large allocations marked as suitable for transparent hugepages
--------------------------------------------------------------
On systems that support transparent hugepages over the madvise system call
numpy now marks that large memory allocations can be backed by hugepages which
reduces page fault overhead and can in some fault heavy cases improve
performance significantly. On Linux the setting for huge pages to be used,
`/sys/kernel/mm/transparent_hugepage/enabled`, must be at least `madvise`.
Systems which already have it set to `always` will not see much difference as
the kernel will automatically use huge pages where appropriate.
Users of very old Linux kernels (~3.x and older) should make sure that
`/sys/kernel/mm/transparent_hugepage/defrag` is not set to `always` to avoid
performance problems due concurrency issues in the memory defragmentation.
Alpine Linux (and other musl c library distros) support
-------------------------------------------------------
We now default to use `fenv.h` for floating point status error reporting.
Previously we had a broken default that sometimes would not report underflow,
overflow, and invalid floating point operations. Now we can support non-glibc
distrubutions like Alpine Linux as long as they ship `fenv.h`.
Speedup ``np.block`` for large arrays
-------------------------------------
Large arrays (greater than ``512 * 512``) now use a blocking algorithm based on
copying the data directly into the appropriate slice of the resulting array.
This results in significant speedups for these large arrays, particularly for
arrays being blocked along more than 2 dimensions.
``arr.ctypes.data_as(...)`` holds a reference to arr
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Previously the caller was responsible for keeping the array alive for the
lifetime of the pointer.
Speedup ``np.take`` for read-only arrays
----------------------------------------
The implementation of ``np.take`` no longer makes an unnecessary copy of the
source array when its ``writeable`` flag is set to ``False``.
Support path-like objects for more functions
--------------------------------------------
The ``np.core.records.fromfile`` function now supports ``pathlib.Path``
and other path-like objects in addition to a file object. Furthermore, the
``np.load`` function now also supports path-like objects when using memory
mapping (``mmap_mode`` keyword argument).
Better behaviour of ufunc identities during reductions
------------------------------------------------------
Universal functions have an ``.identity`` which is used when ``.reduce`` is
called on an empty axis.
As of this release, the logical binary ufuncs, `logical_and`, `logical_or`,
and `logical_xor`, now have ``identity`` s of type `bool`, where previously they
were of type `int`. This restores the 1.14 behavior of getting ``bool`` s when
reducing empty object arrays with these ufuncs, while also keeping the 1.15
behavior of getting ``int`` s when reducing empty object arrays with arithmetic
ufuncs like ``add`` and ``multiply``.
Additionally, `logaddexp` now has an identity of ``-inf``, allowing it to be
called on empty sequences, where previously it could not be.
This is possible thanks to the new
:c:function:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity`, which allows
arbitrary values to be used as identities now.
Improved conversion from ctypes objects
---------------------------------------
Numpy has always supported taking a value or type from ``ctypes`` and
converting it into an array or dtype, but only behaved correctly for simpler
types. As of this release, this caveat is lifted - now:
* The ``_pack_`` attribute of ``ctypes.Structure``, used to emulate C's
``__attribute__((packed))``, is respected.
* Endianness of all ctypes objects is preserved
* ``ctypes.Union`` is supported
* Non-representable constructs raise exceptions, rather than producing
dangerously incorrect results:
* Bitfields are no longer interpreted as sub-arrays
* Pointers are no longer replaced with the type that they point to
A new ``ndpointer.contents`` member
-----------------------------------
This matches the ``.contents`` member of normal ctypes arrays, and can be used
to construct an ``np.array`` around the pointers contents. This replaces
``np.array(some_nd_pointer)``, which stopped working in 1.15. As a side effect
of this change, ``ndpointer`` now supports dtypes with overlapping fields and
padding.
``matmul`` is now a ``ufunc``
-----------------------------
`numpy.matmul` is now a ufunc which means that both the function and the
``__matmul__`` operator can now be overridden by ``__array_ufunc__``. Its
implementation has also changed. It uses the same BLAS routines as
`numpy.dot`, ensuring its performance is similar for large matrices.
Start and stop arrays for ``linspace``, ``logspace`` and ``geomspace``
----------------------------------------------------------------------
These functions used to be limited to scalar stop and start values, but can
now take arrays, which will be properly broadcast and result in an output
which has one axis prepended. This can be used, e.g., to obtain linearly
interpolated points between sets of points.
CI extended with additional services
------------------------------------
We now use additional free CI services, thanks to the companies that provide:
* Codecoverage testing via codecov.io
* Arm testing via shippable.com
* Additional test runs on azure pipelines
These are in addition to our continued use of travis, appveyor (for wheels) and
LGTM
Changes
=======
Comparison ufuncs will now error rather than return NotImplemented
------------------------------------------------------------------
Previously, comparison ufuncs such as ``np.equal`` would return
`NotImplemented` if their arguments had structured dtypes, to help comparison
operators such as ``__eq__`` deal with those. This is no longer needed, as the
relevant logic has moved to the comparison operators proper (which thus do
continue to return `NotImplemented` as needed). Hence, like all other ufuncs,
the comparison ufuncs will now error on structured dtypes.
Positive will now raise a deprecation warning for non-numerical arrays
----------------------------------------------------------------------
Previously, ``+array`` unconditionally returned a copy. Now, it will
raise a ``DeprecationWarning`` if the array is not numerical (i.e.,
if ``np.positive(array)`` raises a ``TypeError``. For ``ndarray``
subclasses that override the default ``__array_ufunc__`` implementation,
the ``TypeError`` is passed on.
``NDArrayOperatorsMixin`` now implements matrix multiplication
--------------------------------------------------------------
Previously, ``np.lib.mixins.NDArrayOperatorsMixin`` did not implement the
special methods for Python's matrix multiplication operator (`). This has
changed now that ``matmul`` is a ufunc and can be overridden using
``__array_ufunc__``.
The scaling of the covariance matrix in ``np.polyfit`` is different
-------------------------------------------------------------------
So far, ``np.polyfit`` used a non-standard factor in the scaling of the the
covariance matrix. Namely, rather than using the standard ``chisq/(M-N)``, it
scaled it with ``chisq/(M-N-2)`` where M is the number of data points and N is the
number of parameters. This scaling is inconsistent with other fitting programs
such as e.g. ``scipy.optimize.curve_fit`` and was changed to ``chisq/(M-N)``.
``maximum`` and ``minimum`` no longer emit warnings
---------------------------------------------------
As part of code introduced in 1.10, ``float32`` and ``float64`` set invalid
float status when a Nan is encountered in `numpy.maximum` and `numpy.minimum`,
when using SSE2 semantics. This caused a `RuntimeWarning` to sometimes be
emitted. In 1.15 we fixed the inconsistencies which caused the warnings to
become more conspicuous. Now no warnings will be emitted.
Umath and multiarray c-extension modules merged into a single module
--------------------------------------------------------------------
The two modules were merged, according to `NEP 15`_. Previously `np.core.umath`
and `np.core.multiarray` were seperate c-extension modules. They are now python
wrappers to the single `np.core/_multiarray_math` c-extension module.
.. _`NEP 15` : http://www.numpy.org/neps/nep-0015-merge-multiarray-umath.html
``getfield`` validity checks extended
-------------------------------------
`numpy.ndarray.getfield` now checks the dtype and offset arguments to prevent
accessing invalid memory locations.
NumPy functions now support overrides with ``__array_function__``
-----------------------------------------------------------------
It is now possible to override the implementation of almost all NumPy functions
on non-NumPy 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/nep-0015-merge-multiarray-umath.html
.. _`NEP 18` : http://www.numpy.org/neps/nep-0018-array-function-protocol.html
Arrays based off readonly buffers cannot be set ``writeable``
-------------------------------------------------------------
We now disallow setting the ``writeable`` flag True on arrays created
from ``fromstring(readonly-buffer)``.
Checksums
=========
MD5
---
4cfd167c553c15cbffacad828e37fa1b numpy-1.16.0rc1-cp27-cp27m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
fc7acd76d8f2f5b69af7b14435ff6e5f numpy-1.16.0rc1-cp27-cp27m-manylinux1_i686.whl
d3d05c0ade6bd5ed26c0d2f045cc2545 numpy-1.16.0rc1-cp27-cp27m-manylinux1_x86_64.whl
78acdc2844f3711e670b5b0d6112fd46 numpy-1.16.0rc1-cp27-cp27m-win32.whl
e24b99a1b2584e5c89a8bb25b755a229 numpy-1.16.0rc1-cp27-cp27m-win_amd64.whl
28df62b2e4162a0be66a65b0405d2974 numpy-1.16.0rc1-cp27-cp27mu-manylinux1_i686.whl
443d09ffded8b4f52d4158e7e53d5e02 numpy-1.16.0rc1-cp27-cp27mu-manylinux1_x86_64.whl
4709d3b87b56e8d706baf998a746baa0 numpy-1.16.0rc1-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
e3895e61d89db8219e01e263f342c91b numpy-1.16.0rc1-cp35-cp35m-manylinux1_i686.whl
b0e7842ece6d07568341ec8c4e850466 numpy-1.16.0rc1-cp35-cp35m-manylinux1_x86_64.whl
4f5de37348d5ab67661277a713e26317 numpy-1.16.0rc1-cp35-cp35m-win32.whl
a629f86585a6a7f22afdcc953df543b5 numpy-1.16.0rc1-cp35-cp35m-win_amd64.whl
69860375de9a74698322e9608d039e24 numpy-1.16.0rc1-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
d75b3ec49d27915ea9ee0866a45b1606 numpy-1.16.0rc1-cp36-cp36m-manylinux1_i686.whl
b103bc43115f9c5760e0f86de7191682 numpy-1.16.0rc1-cp36-cp36m-manylinux1_x86_64.whl
b3c6cbd582b502b6069b9a85a4b52d3f numpy-1.16.0rc1-cp36-cp36m-win32.whl
efde86e04767a20af7d7b671aa43a74e numpy-1.16.0rc1-cp36-cp36m-win_amd64.whl
0da1b6b0fddea9eebcc6d06c161b109d numpy-1.16.0rc1-cp37-cp37m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
439fefdac5de6e80c0213aa5dd3aed83 numpy-1.16.0rc1-cp37-cp37m-manylinux1_i686.whl
a238bdbdaece30f8bdd68cb17b8fc0f3 numpy-1.16.0rc1-cp37-cp37m-manylinux1_x86_64.whl
f27e4791cc0696451572350a64fc3509 numpy-1.16.0rc1-cp37-cp37m-win32.whl
b90d6fefb38650b5a343171dfabe1e38 numpy-1.16.0rc1-cp37-cp37m-win_amd64.whl
acfd5138cd9ba5a0ee434c112866e1d1 numpy-1.16.0rc1.tar.gz
f9a9356b066174b1375d509d7fdf03a6 numpy-1.16.0rc1.zip
SHA256
------
1d94a5649fb8412784d9edda539b266801ee87fc89b812ebf5ec0fdab96444a3 numpy-1.16.0rc1-cp27-cp27m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
f901fa2232562abf9250e4a86d2b50f008b2fe0f9d91bc1ca6a3ffd17c81d2a4 numpy-1.16.0rc1-cp27-cp27m-manylinux1_i686.whl
4c725b6557eb043b963a8b4b5da560fec4500b5e2a9c4794adb408de838aeb94 numpy-1.16.0rc1-cp27-cp27m-manylinux1_x86_64.whl
867ed40b1bebb50f8b060a1b2a76c227a436a7d9fc73bf873dbc8e79862a56af numpy-1.16.0rc1-cp27-cp27m-win32.whl
70279fa434b878692c15bdb9b3376765ff63a91d5f1f6e5973eb34b0bddd7aa5 numpy-1.16.0rc1-cp27-cp27m-win_amd64.whl
c5db80fc344977d3df5435ded1a8ce05719283aeacaaf60a818a4baf63c756e4 numpy-1.16.0rc1-cp27-cp27mu-manylinux1_i686.whl
026a3b7c46e01a736bdf27853ce2a4f56a4feb3147ff879dbd463ed4da0a511b numpy-1.16.0rc1-cp27-cp27mu-manylinux1_x86_64.whl
2a17337e1980e753d4bac3dd4859bc1300e995ddf05fc09828b8d60d932ce4d3 numpy-1.16.0rc1-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
0efbe5f61044e7b0ed5583380aca26995c10cd625266f09b2d6ccef243499f2e numpy-1.16.0rc1-cp35-cp35m-manylinux1_i686.whl
60dd924257899a44d55a7e548aba2a41c12e5d963b900ec138e0b15f3e6f3ef5 numpy-1.16.0rc1-cp35-cp35m-manylinux1_x86_64.whl
078efe4fc53079acb4a70f378a1fbf97f22a1f864321788ae1fd9ca4c952bb10 numpy-1.16.0rc1-cp35-cp35m-win32.whl
3dd416deba0e6b734e653961354ac2bee2888c832835304853b14299a8c3169a numpy-1.16.0rc1-cp35-cp35m-win_amd64.whl
ff9859fffc4a03b196d742fe683684921e3d3819aa97d935b92d573b7ff0bf7b numpy-1.16.0rc1-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
ad0a948011cafe20323944aea7570cea77c3659cf970ee4e94993a75fdf1bf3a numpy-1.16.0rc1-cp36-cp36m-manylinux1_i686.whl
b53714c56ee9a1f1b46f7558ca1aa005704dba35334ff61288390be01b96b3b0 numpy-1.16.0rc1-cp36-cp36m-manylinux1_x86_64.whl
e299aaed551f16c3822e261adc6d5685ad7067536ae6af00e53837b637dc1270 numpy-1.16.0rc1-cp36-cp36m-win32.whl
9c76c0f114b729606081b0e4c49d2f7887946004872576f51b8bd50461f4110b numpy-1.16.0rc1-cp36-cp36m-win_amd64.whl
bcf57e4694e32d7ebb9402cd3fcd9c4fd913a29f372fbefc8edd675a32262558 numpy-1.16.0rc1-cp37-cp37m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl
c953969e4b9a65998be1d7e895613be77bd42d438b54f9ce8c2453616ca8f5c9 numpy-1.16.0rc1-cp37-cp37m-manylinux1_i686.whl
09d327e93f2b13dfbfd6a7c2534441478896a24e9521f59f1ec64c775eff0066 numpy-1.16.0rc1-cp37-cp37m-manylinux1_x86_64.whl
ff73c826d81442f00b38360e52618d94f811c8db9047546d135c0e56117f3812 numpy-1.16.0rc1-cp37-cp37m-win32.whl
f735dad0d72598ca0e19f50a0891e83e496288038628addd86c05650fab49181 numpy-1.16.0rc1-cp37-cp37m-win_amd64.whl
90aa92d9c1bf0cbde34c0eb3964b87d15f2a6de01da99af18615925e3b7d8a05 numpy-1.16.0rc1.tar.gz
6e638a8d56af542aebf625efdacdfb555943c08044795ee7550789407f5b905c numpy-1.16.0rc1.zip