'select', 'piecewise', 'trim_zeros', 'copy', 'iterable', 'percentile',

'diff', 'gradient', 'angle', 'unwrap', 'sort_complex', 'flip',

'rot90', 'extract', 'place', 'vectorize', 'asarray_chkfinite', 'average',

'bincount', 'digitize', 'cov', 'corrcoef',

'median', 'sinc', 'hamming', 'hanning', 'bartlett',

'blackman', 'kaiser', 'trapezoid', 'i0',

'meshgrid', 'delete', 'insert', 'append', 'interp',

'quantile'

# --- HYNDMAN and FAN METHODS

# Discrete methods

'inverted_cdf': {

'get_virtual_index': lambda n, quantiles: _inverted_cdf(n, quantiles),

'fix_gamma': None, # should never be called

},

'averaged_inverted_cdf': {

'get_virtual_index': lambda n, quantiles: (n * quantiles) - 1,

'fix_gamma': lambda gamma, _: _get_gamma_mask(

shape=gamma.shape,

default_value=1.,

conditioned_value=0.5,

where=gamma == 0),

},

'closest_observation': {

'get_virtual_index': lambda n, quantiles: _closest_observation(n, quantiles),

'fix_gamma': None, # should never be called

},

# Continuous methods

'interpolated_inverted_cdf': {

'get_virtual_index': lambda n, quantiles:

_compute_virtual_index(n, quantiles, 0, 1),

'fix_gamma': lambda gamma, _: gamma,

},

'hazen': {

'get_virtual_index': lambda n, quantiles:

_compute_virtual_index(n, quantiles, 0.5, 0.5),

'fix_gamma': lambda gamma, _: gamma,

},

'weibull': {

'get_virtual_index': lambda n, quantiles:

_compute_virtual_index(n, quantiles, 0, 0),

'fix_gamma': lambda gamma, _: gamma,

},

# Default method.

# To avoid some rounding issues, `(n-1) * quantiles` is preferred to

# `_compute_virtual_index(n, quantiles, 1, 1)`.

# They are mathematically equivalent.

'linear': {

'get_virtual_index': lambda n, quantiles: (n - 1) * quantiles,

'fix_gamma': lambda gamma, _: gamma,

},

'median_unbiased': {

'get_virtual_index': lambda n, quantiles:

_compute_virtual_index(n, quantiles, 1 / 3.0, 1 / 3.0),

'fix_gamma': lambda gamma, _: gamma,

},

'normal_unbiased': {

'get_virtual_index': lambda n, quantiles:

_compute_virtual_index(n, quantiles, 3 / 8.0, 3 / 8.0),

'fix_gamma': lambda gamma, _: gamma,

},

# --- OTHER METHODS

'lower': {

'get_virtual_index': lambda n, quantiles: np.floor(

(n - 1) * quantiles).astype(np.intp),

'fix_gamma': None, # should never be called, index dtype is int

},

'higher': {

'get_virtual_index': lambda n, quantiles: np.ceil(

(n - 1) * quantiles).astype(np.intp),

'fix_gamma': None, # should never be called, index dtype is int

},

'midpoint': {

'get_virtual_index': lambda n, quantiles: 0.5 * (

np.floor((n - 1) * quantiles)

+ np.ceil((n - 1) * quantiles)),

'fix_gamma': lambda gamma, index: _get_gamma_mask(

shape=gamma.shape,

default_value=0.5,

conditioned_value=0.,

where=index % 1 == 0),

},

'nearest': {

'get_virtual_index': lambda n, quantiles: np.around(

(n - 1) * quantiles).astype(np.intp),

'fix_gamma': None,

# should never be called, index dtype is int

"""

axes = tuple(axes)

if len(axes) != 2:

raise ValueError("len(axes) must be 2.")

m = asanyarray(m)

if axes[0] == axes[1] or absolute(axes[0] - axes[1]) == m.ndim:

raise ValueError("Axes must be different.")

if (axes[0] >= m.ndim or axes[0] < -m.ndim

or axes[1] >= m.ndim or axes[1] < -m.ndim):

raise ValueError(f"Axes={axes} out of range for array of ndim={m.ndim}.")

try:

k = operator.index(k)

except TypeError:

# DEPRECATED 2026-04-27, NumPy 2.5

msg = (f"Passing a value for k ({k!r}) that is not an integer type has been "

"deprecated in NumPy 2.5. The value will be cast to an integer. In "

"the future this will be an error.")

warnings.warn(msg, DeprecationWarning, stacklevel=2)

k = int(k)

k %= 4

if k == 0:

return m[:]

if k == 2:

return flip(flip(m, axes[0]), axes[1])

axes_list = arange(0, m.ndim)

(axes_list[axes[0]], axes_list[axes[1]]) = (axes_list[axes[1]],

axes_list[axes[0]])

if k == 1:

return transpose(flip(m, axes[1]), axes_list)

else:

# k == 3

"""

if not hasattr(m, 'ndim'):

m = asarray(m)

if axis is None:

indexer = (np.s_[::-1],) * m.ndim

else:

axis = _nx.normalize_axis_tuple(axis, m.ndim)

indexer = [np.s_[:]] * m.ndim

for ax in axis:

indexer[ax] = np.s_[::-1]

indexer = tuple(indexer)

"""

try:

iter(y)

except TypeError:

return False

"""Validate weights array.

wgt = np.asanyarray(weights)

# Sanity checks

if a.shape != wgt.shape:

if axis is None:

raise TypeError(

"Axis must be specified when shapes of a and weights "

"differ.")

if wgt.shape != tuple(a.shape[ax] for ax in axis):

raise ValueError(

"Shape of weights must be consistent with "

"shape of a along specified axis.")

# setup wgt to broadcast along axis

wgt = wgt.transpose(np.argsort(axis))

wgt = wgt.reshape(tuple((s if ax in axis else 1)

for ax, s in enumerate(a.shape)))

keepdims=np._NoValue):

"""

a = np.asanyarray(a)

if axis is not None:

axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")

if keepdims is np._NoValue:

# Don't pass on the keepdims argument if one wasn't given.

keepdims_kw = {}

else:

keepdims_kw = {'keepdims': keepdims}

if weights is None:

avg = a.mean(axis, **keepdims_kw)

avg_as_array = np.asanyarray(avg)

scl = avg_as_array.dtype.type(a.size / avg_as_array.size)

else:

wgt = _weights_are_valid(weights=weights, a=a, axis=axis)

if issubclass(a.dtype.type, (np.integer, np.bool)):

result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8')

else:

result_dtype = np.result_type(a.dtype, wgt.dtype)

scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)

if np.any(scl == 0.0):

raise ZeroDivisionError(

"Weights sum to zero, can't be normalized")

avg = avg_as_array = np.multiply(a, wgt,

dtype=result_dtype).sum(axis, **keepdims_kw) / scl

if returned:

if scl.shape != avg_as_array.shape:

scl = np.broadcast_to(scl, avg_as_array.shape, subok=True).copy()

return avg, scl

else:

"""Convert the input to an array, checking for NaNs or Infs.

a = asarray(a, dtype=dtype, order=order)

if a.dtype.char in typecodes['AllFloat'] and not np.isfinite(a).all():

raise ValueError(

"array must not contain infs or NaNs")

yield x

# support the undocumented behavior of allowing scalars

if np.iterable(condlist):

"""

x = asanyarray(x)

n2 = len(funclist)

# undocumented: single condition is promoted to a list of one condition

if isscalar(condlist) or (

not isinstance(condlist[0], (list, ndarray)) and x.ndim != 0):

condlist = [condlist]

condlist = asarray(condlist, dtype=bool)

n = len(condlist)

if n == n2 - 1: # compute the "otherwise" condition.

condelse = ~np.any(condlist, axis=0, keepdims=True)

condlist = np.concatenate([condlist, condelse], axis=0)

n += 1

elif n != n2:

raise ValueError(

f"with {n} condition(s), either {n} or {n + 1} functions are expected"

)

y = zeros_like(x)

for cond, func in zip(condlist, funclist):

if not isinstance(func, collections.abc.Callable):

y[cond] = func

else:

vals = x[cond]

if vals.size > 0:

y[cond] = func(vals, *args, **kw)

"""

# Check the size of condlist and choicelist are the same, or abort.

if len(condlist) != len(choicelist):

raise ValueError(

'list of cases must be same length as list of conditions')

# Now that the dtype is known, handle the deprecated select([], []) case

if len(condlist) == 0:

raise ValueError("select with an empty condition list is not possible")

# TODO: This preserves the Python int, float, complex manually to get the

# right `result_type` with NEP 50. Most likely we will grow a better

# way to spell this (and this can be replaced).

choicelist = [

choice if type(choice) in (int, float, complex) else np.asarray(choice)

for choice in choicelist]

choicelist.append(default if type(default) in (int, float, complex)

else np.asarray(default))

try:

dtype = np.result_type(*choicelist)

except TypeError as e:

msg = f'Choicelist and default value do not have a common dtype: {e}'

raise TypeError(msg) from None

# Convert conditions to arrays and broadcast conditions and choices

# as the shape is needed for the result. Doing it separately optimizes

# for example when all choices are scalars.

condlist = np.broadcast_arrays(*condlist)

choicelist = np.broadcast_arrays(*choicelist)

# If cond array is not an ndarray in boolean format or scalar bool, abort.

for i, cond in enumerate(condlist):

if cond.dtype.type is not np.bool:

raise TypeError(

f'invalid entry {i} in condlist: should be boolean ndarray')

if choicelist[0].ndim == 0:

# This may be common, so avoid the call.

result_shape = condlist[0].shape

else:

result_shape = np.broadcast_arrays(condlist[0], choicelist[0])[0].shape

result = np.full(result_shape, choicelist[-1], dtype)

# Use np.copyto to burn each choicelist array onto result, using the

# corresponding condlist as a boolean mask. This is done in reverse

# order since the first choice should take precedence.

choicelist = choicelist[-2::-1]

condlist = condlist[::-1]

for choice, cond in zip(choicelist, condlist):

np.copyto(result, choice, where=cond)

"""