NumPy 1.24.0 Release Notes#

Expired deprecations#

  • The normed keyword argument has been removed from np.histogram, np.histogram2d, and np.histogramdd. Use density instead. If normed was passed by position, density is now used.


Compatibility notes#

array.fill(scalar) may behave slightly different#

fill may in some cases behave slightly different now due to the fact that the logic is aligned with item assignment:

arr = np.array([1])  # with any dtype/value
# is now identical to:
arr[0] = scalar

Previously casting may have produced slightly different answers when using values that could not be represented in the target dtype or when the target had object dtype.


New Features#

New attribute symbol added to polynomial classes#

The polynomial classes in the numpy.polynomial package have a new symbol attribute which is used to represent the indeterminate of the polynomial. This can be used to change the value of the variable when printing:

>>> P_y = np.polynomial.Polynomial([1, 0, -1], symbol="y")
>>> print(P_y)
1.0 + 0.0·y¹ - 1.0·y²

Note that the polynomial classes only support 1D polynomials, so operations that involve polynomials with different symbols are disallowed when the result would be multivariate:

>>> P = np.polynomial.Polynomial([1, -1])  # default symbol is "x"
>>> P_z = np.polynomial.Polynomial([1, 1], symbol="z")
>>> P * P_z
Traceback (most recent call last)
ValueError: Polynomial symbols differ

The symbol can be any valid Python identifier. The default is symbol=x, consistent with existing behavior.


F2PY support for Fortran character strings#

F2PY now supports wrapping Fortran functions with:

  • character (e.g. character x)

  • character array (e.g. character, dimension(n) :: x)

  • character string (e.g. character(len=10) x)

  • and character string array (e.g. character(len=10), dimension(n, m) :: x)

arguments, including passing Python unicode strings as Fortran character string arguments.


strict option for testing.assert_array_equal#

The strict option is now available for testing.assert_array_equal. Setting strict=True will disable the broadcasting behaviour for scalars and ensure that input arrays have the same data type.


New parameter equal_nan added to np.unique#

np.unique was changed in 1.21 to treat all NaN values as equal and return a single NaN. Setting equal_nan=False will restore pre-1.21 behavior to treat NaNs as unique. Defaults to True.


casting and dtype keyword arguments for numpy.stack#

The casting and dtype keyword arguments are now available for numpy.stack. To use them, write np.stack(..., dtype=None, casting='same_kind').

casting and dtype keyword arguments for numpy.vstack#

The casting and dtype keyword arguments are now available for numpy.vstack. To use them, write np.vstack(..., dtype=None, casting='same_kind').

casting and dtype keyword arguments for numpy.hstack#

The casting and dtype keyword arguments are now available for numpy.hstack. To use them, write np.hstack(..., dtype=None, casting='same_kind').



F2PY Improvements#

  • The generated extension modules don’t use the deprecated NumPy-C API anymore

  • Improved f2py generated exception messages

  • Numerous bug and flake8 warning fixes

  • various CPP macros that one can use within C-expressions of signature files are prefixed with f2py_. For example, one should use f2py_len(x) instead of len(x)

  • A new construct character(f2py_len=...) is introduced to support returning assumed length character strings (e.g. character(len=*)) from wrapper functions

A hook to support rewriting f2py internal data structures after reading all its input files is introduced. This is required, for instance, for BC of SciPy support where character arguments are treated as character strings arguments in C expressions.


IBM zSystems Vector Extension Facility (SIMD)#

Added support for SIMD extensions of zSystem (z13, z14, z15), through the universal intrinsics interface. This support leads to performance improvements for all SIMD kernels implemented using the universal intrinsics, including the following operations:

rint, floor, trunc, ceil, sqrt, absolute, square, reciprocal, tanh, sin, cos, equal, not_equal, greater, greater_equal, less, less_equal, maximum, minimum, fmax, fmin, argmax, argmin, add, subtract, multiply, divide.


NumPy now gives floating point errors in casts#

In most cases, NumPy previously did not give floating point warnings or errors when these happened during casts. For examples, casts like:

np.array([2e300]).astype(np.float32)  # overflow for float32

Should now generally give floating point warnings. These warnings should warn that floating point overflow occurred. For errors when converting floating point values to integers users should expect invalid value warnings.

Users can modify the behavior of these warnings using np.errstate.

Note that for float to int casts, the exact warnings that are given may be platform dependend. For example:

arr = np.full(100, value=1000, dtype=np.float64)

May give a result equivalent to (the intermediat means no warning is given):


May may return an undefined result, with a warning set:

RuntimeWarning: invalid value encountered in cast

The precise behavior if subject to the C99 standard and its implementation in both software and hardware.


F2PY supports the value attribute#

The Fortran standard requires that variables declared with the value attribute must be passed by value instead of reference. F2PY now supports this use pattern correctly. So integer, intent(in), value :: x in Fortran codes will have correct wrappers generated.


Performance improvements and changes#

Faster version of np.isin and np.in1d for integer arrays#

np.in1d (used by np.isin) can now switch to a faster algorithm (up to >10x faster) when it is passed two integer arrays. This is often automatically used, but you can use kind="sort" or kind="table" to force the old or new method, respectively.


Faster comparison operators#

The comparison functions (numpy.equal, numpy.not_equal, numpy.less, numpy.less_equal, numpy.greater and numpy.greater_equal) are now much faster as they are now vectorized with universal intrinsics. For a CPU with SIMD extension AVX512BW, the performance gain is up to 2.57x, 1.65x and 19.15x for integer, float and boolean data types, respectively (with N=50000).


NumPy 1.24.0 Release Notes#


New functions#


Future Changes#

Expired deprecations#

Compatibility notes#

C API changes#

New Features#