Skip to main content
`Ctrl`+`K`

# NumPy 1.22.0 Release Notes

NumPy 1.22.0 is a big release featuring the work of 153 contributors spread over 609 pull requests. There have been many improvements, highlights are:

- Annotations of the main namespace are essentially complete. Upstream is a moving target, so there will likely be further improvements, but the major work is done. This is probably the most user visible enhancement in this release.

- A preliminary version of the proposed Array-API is provided. This is a step in creating a standard collection of functions that can be used across applications such as CuPy and JAX.

- NumPy now has a DLPack backend. DLPack provides a common interchange format for array (tensor) data.

- New methods for `quantile`, `percentile`, and related functions. The new methods provide a complete set of the methods commonly found in the literature.

- The universal functions have been refactored to implement most of NEP 43. This also unlocks the ability to experiment with the future DType API.

- A new configurable allocator for use by downstream projects.

These are in addition to the ongoing work to provide SIMD support for commonly used functions, improvements to F2PY, and better documentation.

The Python versions supported in this release are 3.8-3.10, Python 3.7 has been dropped. Note that the Mac wheels are now based on OS X 10.14 rather than 10.9 that was used in previous NumPy release cycles. 10.14 is the oldest release supported by Apple. Also note that 32 bit wheels are only provided for Python 3.8 and 3.9 on Windows, all other wheels are 64 bits on account of Ubuntu, Fedora, and other Linux distributions dropping 32 bit support. All 64 bit wheels are also linked with 64 bit integer OpenBLAS, which should fix the occasional problems encountered by folks using truly huge arrays.

## Expired deprecations

### Deprecated numeric style dtype strings have been removed

Using the strings `"Bytes0"`, `"Datetime64"`, `"Str0"`, `"Uint32"`, and `"Uint64"` as a dtype will now raise a `TypeError`.

(gh-19539)

### Expired deprecations for `loads`, `ndfromtxt`, and `mafromtxt` in npyio

`numpy.loads` was deprecated in v1.15, with the recommendation that users use `pickle.loads` instead. `ndfromtxt` and `mafromtxt` were both deprecated in v1.17 - users should use `numpy.genfromtxt` instead with the appropriate value for the `usemask` parameter.

(gh-19615)

## Deprecations

### Use delimiter rather than delimitor as kwarg in mrecords

The misspelled keyword argument `delimitor` of `numpy.ma.mrecords.fromtextfile()` has been changed to `delimiter`, using it will emit a deprecation warning.

(gh-19921)

### Passing boolean `kth` values to (arg-)partition has been deprecated

`numpy.partition` and `numpy.argpartition` would previously accept boolean values for the `kth` parameter, which would subsequently be converted into integers. This behavior has now been deprecated.

(gh-20000)

### The `np.MachAr` class has been deprecated

The `numpy.MachAr` class and `finfo.machar <numpy.finfo>` attribute have been deprecated. Users are encouraged to access the property if interest directly from the corresponding `numpy.finfo` attribute.

(gh-20201)

## Compatibility notes

### Distutils forces strict floating point model on clang

NumPy now sets the `-ftrapping-math` option on clang to enforce correct floating point error handling for universal functions. Clang defaults to non-IEEE and C99 conform behaviour otherwise. This change (using the equivalent but newer `-ffp-exception-behavior=strict`) was attempted in NumPy 1.21, but was effectively never used.

(gh-19479)

### Removed floor division support for complex types

Floor division of complex types will now result in a `TypeError`

    >>> a = np.arange(10) + 1j* np.arange(10)
    >>> a // 1
    TypeError: ufunc 'floor_divide' not supported for the input types...

(gh-19135)

### `numpy.vectorize` functions now produce the same output class as the base function

When a function that respects `numpy.ndarray` subclasses is vectorized using `numpy.vectorize`, the vectorized function will now be subclass-safe also for cases that a signature is given (i.e., when creating a `gufunc`): the output class will be the same as that returned by the first call to the underlying function.

(gh-19356)

### Python 3.7 is no longer supported

Python support has been dropped. This is rather strict, there are changes that require Python >= 3.8.

(gh-19665)

### str/repr of complex dtypes now include space after punctuation

The repr of `np.dtype({"names": ["a"], "formats": [int], "offsets": [2]})` is now `dtype({'names': ['a'], 'formats': ['<i8'], 'offsets': [2], 'itemsize': 10})`, whereas spaces where previously omitted after colons and between fields.

The old behavior can be restored via `np.set_printoptions(legacy="1.21")`.

(gh-19687)

### Corrected `advance` in `PCG64DSXM` and `PCG64`

Fixed a bug in the `advance` method of `PCG64DSXM` and `PCG64`. The bug only affects results when the step was larger than \(2^{64}\) on platforms that do not support 128-bit integers(e.g., Windows and 32-bit Linux).

(gh-20049)

### Change in generation of random 32 bit floating point variates

There was bug in the generation of 32 bit floating point values from the uniform distribution that would result in the least significant bit of the random variate always being 0. This has been fixed.

This change affects the variates produced by the `random.Generator` methods `random`, `standard_normal`, `standard_exponential`, and `standard_gamma`, but only when the dtype is specified as `numpy.float32`.

(gh-20314)

## C API changes

### Masked inner-loops cannot be customized anymore

The masked inner-loop selector is now never used. A warning will be given in the unlikely event that it was customized.

We do not expect that any code uses this. If you do use it, you must unset the selector on newer NumPy version. Please also contact the NumPy developers, we do anticipate providing a new, more specific, mechanism.

The customization was part of a never-implemented feature to allow for faster masked operations.

(gh-19259)

### Experimental exposure of future DType and UFunc API

The new header `experimental_public_dtype_api.h` allows to experiment with future API for improved universal function and especially user DType support. At this time it is advisable to experiment using the development version of NumPy since some changes are expected and new features will be unlocked.

(gh-19919)

## New Features

### NEP 49 configurable allocators

As detailed in NEP 49, the function used for allocation of the data segment of a ndarray can be changed. The policy can be set globally or in a context. For more information see the NEP and the Memory management in NumPy reference docs. Also add a `NUMPY_WARN_IF_NO_MEM_POLICY` override to warn on dangerous use of transferring ownership by setting `NPY_ARRAY_OWNDATA`.

(gh-17582)

### Implementation of the NEP 47 (adopting the array API standard)

An initial implementation of NEP 47 (adoption the array API standard) has been added as `numpy.array_api`. The implementation is experimental and will issue a UserWarning on import, as the array API standard is still in draft state. `numpy.array_api` is a conforming implementation of the array API standard, which is also minimal, meaning that only those functions and behaviors that are required by the standard are implemented (see the NEP for more info). Libraries wishing to make use of the array API standard are encouraged to use `numpy.array_api` to check that they are only using functionality that is guaranteed to be present in standard conforming implementations.

(gh-18585)

### Generate C/C++ API reference documentation from comments blocks is now possible

This feature depends on Doxygen in the generation process and on Breathe to integrate it with Sphinx.

(gh-18884)

### Assign the platform-specific `c_intp` precision via a mypy plugin

The mypy plugin, introduced in numpy/numpy#17843, has again been expanded: the plugin now is now responsible for setting the platform-specific precision of `numpy.ctypeslib.c_intp`, the latter being used as data type for various `numpy.ndarray.ctypes` attributes.

Without the plugin, aforementioned type will default to `ctypes.c_int64`.

To enable the plugin, one must add it to their mypy configuration file:

    [mypy]
    plugins = numpy.typing.mypy_plugin

(gh-19062)

### Add NEP 47-compatible dlpack support

Add a `ndarray.__dlpack__()` method which returns a `dlpack` C structure wrapped in a `PyCapsule`. Also add a `np._from_dlpack(obj)` function, where `obj` supports `__dlpack__()`, and returns an `ndarray`.

(gh-19083)

### `keepdims` optional argument added to `numpy.argmin`, `numpy.argmax`

`keepdims` argument is added to `numpy.argmin`, `numpy.argmax`. If set to `True`, the axes which are reduced are left in the result as dimensions with size one. The resulting array has the same number of dimensions and will broadcast with the input array.

(gh-19211)

### `bit_count` to compute the number of 1-bits in an integer

Computes the number of 1-bits in the absolute value of the input. This works on all the numpy integer types. Analogous to the builtin `int.bit_count` or `popcount` in C++.

    >>> np.uint32(1023).bit_count()
    10
    >>> np.int32(-127).bit_count()
    7

(gh-19355)

### The `ndim` and `axis` attributes have been added to `numpy.AxisError`

The `ndim` and `axis` parameters are now also stored as attributes within each `numpy.AxisError` instance.

(gh-19459)

### Preliminary support for `windows/arm64` target

`numpy` added support for windows/arm64 target. Please note `OpenBLAS` support is not yet available for windows/arm64 target.

(gh-19513)

### Added support for LoongArch

LoongArch is a new instruction set, numpy compilation failure on LoongArch architecture, so add the commit.

(gh-19527)

### A `.clang-format` file has been added

Clang-format is a C/C++ code formatter, together with the added `.clang-format` file, it produces code close enough to the NumPy C_STYLE_GUIDE for general use. Clang-format version 12+ is required due to the use of several new features, it is available in Fedora 34 and Ubuntu Focal among other distributions.

(gh-19754)

### `is_integer` is now available to `numpy.floating` and `numpy.integer`

Based on its counterpart in Python `float` and `int`, the numpy floating point and integer types now support `float.is_integer`. Returns `True` if the number is finite with integral value, and `False` otherwise.

    >>> np.float32(-2.0).is_integer()
    True
    >>> np.float64(3.2).is_integer()
    False
    >>> np.int32(-2).is_integer()
    True

(gh-19803)

### Symbolic parser for Fortran dimension specifications

A new symbolic parser has been added to f2py in order to correctly parse dimension specifications. The parser is the basis for future improvements and provides compatibility with Draft Fortran 202x.

(gh-19805)

### `ndarray`, `dtype` and `number` are now runtime-subscriptable

Mimicking PEP 585, the `numpy.ndarray`, `numpy.dtype` and `numpy.number` classes are now subscriptable for python 3.9 and later. Consequently, expressions that were previously only allowed in .pyi stub files or with the help of `from __future__ import annotations` are now also legal during runtime.

    >>> import numpy as np
    >>> from typing import Any

    >>> np.ndarray[Any, np.dtype[np.float64]]
    numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]]

(gh-19879)

## Improvements

### `ctypeslib.load_library` can now take any path-like object

All parameters in the can now take any path-like object. This includes the likes of strings, bytes and objects implementing the `__fspath__` protocol.

(gh-17530)

### Add `smallest_normal` and `smallest_subnormal` attributes to `finfo`

The attributes `smallest_normal` and `smallest_subnormal` are available as an extension of `finfo` class for any floating-point data type. To use these new attributes, write `np.finfo(np.float64).smallest_normal` or `np.finfo(np.float64).smallest_subnormal`.

(gh-18536)

### `numpy.linalg.qr` accepts stacked matrices as inputs

`numpy.linalg.qr` is able to produce results for stacked matrices as inputs. Moreover, the implementation of QR decomposition has been shifted to C from Python.

(gh-19151)

### `numpy.fromregex` now accepts `os.PathLike` implementations

`numpy.fromregex` now accepts objects implementing the `__fspath__<os.PathLike>` protocol, e.g. `pathlib.Path`.

(gh-19680)

### Add new methods for `quantile` and `percentile`

`quantile` and `percentile` now have have a `method=` keyword argument supporting 13 different methods. This replaces the `interpolation=` keyword argument.

The methods are now aligned with nine methods which can be found in scientific literature and the R language. The remaining methods are the previous discontinuous variations of the default “linear” one.

Please see the documentation of `numpy.percentile` for more information.

(gh-19857)

### Missing parameters have been added to the `nan<x>` functions

A number of the `nan<x>` functions previously lacked parameters that were present in their `<x>`-based counterpart, e.g. the `where` parameter was present in `numpy.mean` but absent from `numpy.nanmean`.

The following parameters have now been added to the `nan<x>` functions:

- nanmin: `initial` & `where`

- nanmax: `initial` & `where`

- nanargmin: `keepdims` & `out`

- nanargmax: `keepdims` & `out`

- nansum: `initial` & `where`

- nanprod: `initial` & `where`

- nanmean: `where`

- nanvar: `where`

- nanstd: `where`

(gh-20027)

### Annotating the main Numpy namespace

Starting from the 1.20 release, PEP 484 type annotations have been included for parts of the NumPy library; annotating the remaining functions being a work in progress. With the release of 1.22 this process has been completed for the main NumPy namespace, which is now fully annotated.

Besides the main namespace, a limited number of sub-packages contain annotations as well. This includes, among others, `numpy.testing`, `numpy.linalg` and `numpy.random` (available since 1.21).

(gh-20217)

### Vectorize umath module using AVX-512

By leveraging Intel Short Vector Math Library (SVML), 18 umath functions (`exp2`, `log2`, `log10`, `expm1`, `log1p`, `cbrt`, `sin`, `cos`, `tan`, `arcsin`, `arccos`, `arctan`, `sinh`, `cosh`, `tanh`, `arcsinh`, `arccosh`, `arctanh`) are vectorized using AVX-512 instruction set for both single and double precision implementations. This change is currently enabled only for Linux users and on processors with AVX-512 instruction set. It provides an average speed up of 32x and 14x for single and double precision functions respectively.

(gh-19478)

### OpenBLAS v0.3.18

Update the OpenBLAS used in testing and in wheels to v0.3.18

(gh-20058)