numpy max vs amax vs maximum
Question:
numpy has three different functions which seem like they can be used for the same things — except that numpy.maximum
can only be used elementwise, while numpy.max
and numpy.amax
can be used on particular axes, or all elements. Why is there more than just numpy.max
? Is there some subtlety to this in performance?
(Similarly for min
vs. amin
vs. minimum
)
Answers:
You’ve already stated why np.maximum
is different – it returns an array that is the elementwise maximum between two arrays.
As for np.amax
and np.max
: they both call the same function – np.max
is just an alias for np.amax
, and they compute the maximum of all elements in an array, or along an axis of an array.
In [1]: import numpy as np
In [2]: np.amax
Out[2]: <function numpy.core.fromnumeric.amax>
In [3]: np.max
Out[3]: <function numpy.core.fromnumeric.amax>
np.max
is just an alias for np.amax
. This function only works on a single input array and finds the value of maximum element in that entire array (returning a scalar). Alternatively, it takes an axis
argument and will find the maximum value along an axis of the input array (returning a new array).
>>> a = np.array([[0, 1, 6],
[2, 4, 1]])
>>> np.max(a)
6
>>> np.max(a, axis=0) # max of each column
array([2, 4, 6])
The default behaviour of np.maximum
is to take two arrays and compute their elementwise maximum. Here, ‘compatible’ means that one array can be broadcast to the other. For example:
>>> b = np.array([3, 6, 1])
>>> c = np.array([4, 2, 9])
>>> np.maximum(b, c)
array([4, 6, 9])
But np.maximum
is also a universal function which means that it has other features and methods which come in useful when working with multidimensional arrays. For example you can compute the cumulative maximum over an array (or a particular axis of the array):
>>> d = np.array([2, 0, 3, 4, 2, 7, 9])
>>> np.maximum.accumulate(d)
array([2, 2, 3, 3, 3, 7, 9])
This is not possible with np.max
.
You can make np.maximum
imitate np.max
to a certain extent when using np.maximum.reduce
:
>>> np.maximum.reduce(d)
9
>>> np.max(d)
9
Basic testing suggests the two approaches are comparable in performance; and they should be, as np.max()
actually calls np.maximum.reduce
to do the computation.
For completeness, in Numpy there are four maximum related functions. They fall into two different categories:
np.amax/np.max
,np.nanmax
: for single array order statistics and
np.maximum
,np.fmax
: for elementwise comparison of two arrays
I. For single array order statistics
NaNs propagator np.amax/np.max
and its NaN ignorant counterpart np.nanmax
.

np.max
is just an alias ofnp.amax
, so they are considered as one function.>>> np.max.__name__ 'amax' >>> np.max is np.amax True

np.max
propagates NaNs whilenp.nanmax
ignores NaNs.>>> np.max([np.nan, 3.14, 1]) nan >>> np.nanmax([np.nan, 3.14, 1]) 3.14
II. For elementwise comparison of two arrays
NaNs propagator np.maximum
and its NaNs ignorant counterpart np.fmax
.

Both functions require two arrays as the first two positional args to compare with.
# x1 and x2 must be the same shape or can be broadcast np.maximum(x1, x2, /, ...); np.fmax(x1, x2, /, ...)

np.maximum
propagates NaNs whilenp.fmax
ignores NaNs.>>> np.maximum([np.nan, 3.14, 0], [np.NINF, np.nan, 2.72]) array([ nan, nan, 2.72]) >>> np.fmax([np.nan, 3.14, 0], [np.NINF, np.nan, 2.72]) array([inf, 3.14, 2.72])

The elementwise functions are
np.ufunc
(Universal Function), which means they have some special properties that normal Numpy function don’t have.>>> type(np.maximum) <class 'numpy.ufunc'> >>> type(np.fmax) <class 'numpy.ufunc'> >>> ## >>> type(np.max) <class 'function'> >>> type(np.nanmax) <class 'function'>
And finally, the same rules apply to the four minimum related functions:
np.amin/np.min
,np.nanmin
; and
np.minimum
,np.fmin
.
np.maximum
not only compares elementwise but also compares array elementwise with single value
>>>np.maximum([23, 14, 16, 20, 25], 18)
array([23, 18, 18, 20, 25])