Skip to content

v1.16.0
Compare
Choose a tag to compare
@charris charris released this 14 Jan 03:06
v1.16.0
This tag was signed with the committer’s verified signature.
charris Charles Harris
GPG key ID: 679F228377C5247B
Verified
Learn about vigilant mode.
971e2e8

==========================
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.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. Usenumpy.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
---

    67d46af4e62111285f27a9c5731f16f9  numpy-1.16.0-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
    a1afdd521bf4480f4a5f43f39a345a80  numpy-1.16.0-cp27-cp27m-manylinux1_i686.whl
    66d2e3fee4504c371da147a56fa9f900  numpy-1.16.0-cp27-cp27m-manylinux1_x86_64.whl
    63648ca2ba0dae7f7f57cc8fc87f0fba  numpy-1.16.0-cp27-cp27m-win32.whl
    9a53cf0c5e77f02ea9b5ff3587a1f8ac  numpy-1.16.0-cp27-cp27m-win_amd64.whl
    7253e6e78dc1ae134abcf40201ca73ad  numpy-1.16.0-cp27-cp27mu-manylinux1_i686.whl
    c47496091e10e31eeb9d9b07f3136237  numpy-1.16.0-cp27-cp27mu-manylinux1_x86_64.whl
    048918abcf3936c947d06f1ee629757e  numpy-1.16.0-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
    968ea61a147bd500b5d858b91ccf709d  numpy-1.16.0-cp35-cp35m-manylinux1_i686.whl
    ee52de6e269576f468285b0f45fe9618  numpy-1.16.0-cp35-cp35m-manylinux1_x86_64.whl
    608e1d02d014bda5c4081881a25f9fbc  numpy-1.16.0-cp35-cp35m-win32.whl
    4ed0e6114562eefb75da7aadc3db4f8a  numpy-1.16.0-cp35-cp35m-win_amd64.whl
    809ed96a113cf46e81ae50c9703e7a5c  numpy-1.16.0-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
    26ceb7aa63fa82bc444e69156444fe6f  numpy-1.16.0-cp36-cp36m-manylinux1_i686.whl
    5877c113fcd82198ad2285e3074a089c  numpy-1.16.0-cp36-cp36m-manylinux1_x86_64.whl
    2ce0cc7d22e3f94e51315c1df4fd81bd  numpy-1.16.0-cp36-cp36m-win32.whl
    b1e5a08c6a85c8a51f8039b3dc3dad3d  numpy-1.16.0-cp36-cp36m-win_amd64.whl
    748fe792a69f79b0c3a926139b23bdbc  numpy-1.16.0-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
    d424c537c28510340f06a317608d7743  numpy-1.16.0-cp37-cp37m-manylinux1_i686.whl
    8d87c0b1f8d7ad46b1976328d6c66cef  numpy-1.16.0-cp37-cp37m-manylinux1_x86_64.whl
    25da2b41f81d4862bb36a07218477ea6  numpy-1.16.0-cp37-cp37m-win32.whl
    22af7b6ff2da30fca2334886fdbf8573  numpy-1.16.0-cp37-cp37m-win_amd64.whl
    d30393335b59081555fa29c680ab4784  numpy-1.16.0.tar.gz
    90b5ec981eb9746785f43e9bfc003fed  numpy-1.16.0.zip

SHA256
------

    a80ecac5664f420556a725a5646f2d1c60a7c0489d68a38b5056393e949e27ac  numpy-1.16.0-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
    be43df2c563e264b38e3318574d80fc8f365df3fb745270934d2dbe54e006f41  numpy-1.16.0-cp27-cp27m-manylinux1_i686.whl
    f00a2c21f60284e024bba351875f3501c6d5817d64997a0afe4f4355161a8889  numpy-1.16.0-cp27-cp27m-manylinux1_x86_64.whl
    5774d49516c37fd3fc1f232e033d2b152f3323ca4c7bfefd7277e4c67f3c08b4  numpy-1.16.0-cp27-cp27m-win32.whl
    25600e8901012180a1b7cd1ac3e27e7793586ecd432383191929ac2edf37ff5d  numpy-1.16.0-cp27-cp27m-win_amd64.whl
    803b2af862dcad6c11231ea3cd1015d1293efd6c87088be33d713a9b23e9e419  numpy-1.16.0-cp27-cp27mu-manylinux1_i686.whl
    24a9c287a4a1c427c2d45bf7c4fc6180c52a08fa0990d4c94e4c86a9b1e23ba5  numpy-1.16.0-cp27-cp27mu-manylinux1_x86_64.whl
    96e49a0c82b4e3130093002f625545104037c2d25866fa2e0c90d6e54f5a1fbc  numpy-1.16.0-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
    a1dd8221f0e69038748f47b8bb3248d0b9ecdf13fe837440951c3d5ff72639bb  numpy-1.16.0-cp35-cp35m-manylinux1_i686.whl
    3e90a9fce378114b6c2fc01fff7423300515c7b54b7cc71b02a22bc0bd7dfdd8  numpy-1.16.0-cp35-cp35m-manylinux1_x86_64.whl
    0470c5dc32212a08ebc2405f32e8ceb9a5b1c8ac61a2daf9835ec0856a220495  numpy-1.16.0-cp35-cp35m-win32.whl
    c40cb17188f6ae3c5b6efc6f0fd43a7ddd219b7807fe179e71027849a9b91afc  numpy-1.16.0-cp35-cp35m-win_amd64.whl
    00a458d6821b1e87be873f2126d5646b901047a7480e8ae9773ecf214f0e19f3  numpy-1.16.0-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
    f1232f98a6bbd6d1678249f94028bccc541bbc306aa5c4e1471a881b0e5a3409  numpy-1.16.0-cp36-cp36m-manylinux1_i686.whl
    2d279bd99329e72c30937bdef82b6dc7779c7607c5a379bab1bf76be1f4c1422  numpy-1.16.0-cp36-cp36m-manylinux1_x86_64.whl
    95c830b09626508f7808ce7f1344fb98068e63143e6050e5dc3063142fc60007  numpy-1.16.0-cp36-cp36m-win32.whl
    ef4ae41add536cb825d8aa029c15ef510aead06ea5b68daea64f0b9ecbff17db  numpy-1.16.0-cp36-cp36m-win_amd64.whl
    32af2bcf4bb7631dac19736a6e092ec9715e770dcaa1f85fcd99dec5040b2a4d  numpy-1.16.0-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
    c6251e0f0ecac53ba2b99d9f0cc16fa9021914a78869c38213c436ba343641f0  numpy-1.16.0-cp37-cp37m-manylinux1_i686.whl
    b19a47ff1bd2fca0cacdfa830c967746764c32dca6a0c0328d9c893f4bfe2f6b  numpy-1.16.0-cp37-cp37m-manylinux1_x86_64.whl
    fea682f6ddc09517df0e6d5caad9613c6d91a42232aeb082df67e4d205de19cc  numpy-1.16.0-cp37-cp37m-win32.whl
    64ff21aac30d40c20ba994c94a08d439b8ced3b9c704af897e9e4ba09d10e62c  numpy-1.16.0-cp37-cp37m-win_amd64.whl
    9b98898687b5dd05c4ac7bcf7e8669a50dd2bb19591b772e045e5806c23e0ca4  numpy-1.16.0.tar.gz
    cb189bd98b2e7ac02df389b6212846ab20661f4bafe16b5a70a6f1728c1cc7cb  numpy-1.16.0.zip
Assets 6
Loading