def flip(a, axis=None):
"""Reverse the order of elements in an array along the given axis.
Note that ``flip`` function has been introduced since NumPy v1.12.
The contents of this document is the same as the original one.
Args:
a (~cupy.ndarray): Input array.
axis (int or tuple of int or None): Axis or axes along which to flip
over. The default, ``axis=None``, will flip over all of the axes of
the input array. If axis is negative it counts from the last to the
first axis. If axis is a tuple of ints, flipping is performed on
all of the axes specified in the tuple.
Returns:
~cupy.ndarray: Output array.
.. seealso:: :func:`numpy.flip`
"""
a_ndim = a.ndim
if a_ndim < 1:
raise numpy.AxisError('Input must be >= 1-d')
axes = internal._normalize_axis_indices(axis, a_ndim)
return _flip(a, axes)
def _init_nd_and_axes(x, axes):
# See documentation in scipy.fft._helper._init_nd_shape_and_axes
# except shape argument is always None and doesn't return new shape
axes = internal._normalize_axis_indices(axes, x.ndim, sort_axes=False)
if not len(axes):
raise ValueError('when provided, axes cannot be empty')
if any(x.shape[ax] < 1 for ax in axes):
raise ValueError('invalid number of data points specified')
return axes
def _gradient(self, xp, dtype, shape, spacing, axis, edge_order):
x = testing.shaped_random(shape, xp, dtype=dtype)
if axis == 'tuple':
if x.ndim == 1:
axis = (0, )
else:
axis = (0, -1)
normalized_axes = internal._normalize_axis_indices(axis, x.ndim)
if spacing == 'sequence of int':
# one scalar per axis
spacing = tuple((ax + 1) / x.ndim for ax in normalized_axes)
elif spacing == 'arrays':
# one array per axis
spacing = tuple(
xp.arange(x.shape[ax]) * (ax + 0.5) for ax in normalized_axes)
# make at one of the arrays have non-constant spacing
spacing[-1][5:] *= 2.0
elif spacing == 'mixed':
# mixture of arrays and scalars
spacing = [xp.arange(x.shape[normalized_axes[0]])]
spacing = spacing + [0.5] * (len(normalized_axes) - 1)
return xp.gradient(x, *spacing, axis=axis, edge_order=edge_order)
def gradient(f, *varargs, axis=None, edge_order=1):
"""Return the gradient of an N-dimensional array.
The gradient is computed using second order accurate central differences
in the interior points and either first or second order accurate one-sides
(forward or backwards) differences at the boundaries.
The returned gradient hence has the same shape as the input array.
Args:
f (cupy.ndarray): An N-dimensional array containing samples of a scalar
function.
varargs (list of scalar or array, optional): Spacing between f values.
Default unitary spacing for all dimensions. Spacing can be
specified using:
1. single scalar to specify a sample distance for all dimensions.
2. N scalars to specify a constant sample distance for each
dimension. i.e. `dx`, `dy`, `dz`, ...
3. N arrays to specify the coordinates of the values along each
dimension of F. The length of the array must match the size of
the corresponding dimension
4. Any combination of N scalars/arrays with the meaning of 2. and
3.
If `axis` is given, the number of varargs must equal the number of
axes. Default: 1.
edge_order ({1, 2}, optional): The gradient is calculated using N-th
order accurate differences at the boundaries. Default: 1.
axis (None or int or tuple of ints, optional): The gradient is
calculated only along the given axis or axes. The default
(axis = None) is to calculate the gradient for all the axes of the
input array. axis may be negative, in which case it counts from the
last to the first axis.
Returns:
gradient (cupy.ndarray or list of cupy.ndarray): A set of ndarrays
(or a single ndarray if there is only one dimension) corresponding
to the derivatives of f with respect to each dimension. Each
derivative has the same shape as f.
.. seealso:: :func:`numpy.gradient`
"""
f = cupy.asanyarray(f)
ndim = f.ndim # number of dimensions
if axis is None:
axes = tuple(range(ndim))
else:
axes = internal._normalize_axis_indices(axis, ndim)
len_axes = len(axes)
n = len(varargs)
if n == 0:
# no spacing argument - use 1 in all axes
dx = [1.0] * len_axes
elif n == 1 and cupy.ndim(varargs[0]) == 0:
# single scalar for all axes
dx = varargs * len_axes
elif n == len_axes:
# scalar or 1d array for each axis
dx = list(varargs)
for i, distances in enumerate(dx):
if cupy.ndim(distances) == 0:
continue
elif cupy.ndim(distances) != 1:
raise ValueError("distances must be either scalars or 1d")
if len(distances) != f.shape[axes[i]]:
raise ValueError("when 1d, distances must match "
"the length of the corresponding dimension")
if numpy.issubdtype(distances.dtype, numpy.integer):
# Convert numpy integer types to float64 to avoid modular
# arithmetic in np.diff(distances).
distances = distances.astype(numpy.float64)
diffx = cupy.diff(distances)
# if distances are constant reduce to the scalar case
# since it brings a consistent speedup
if (diffx == diffx[0]).all(): # synchronize
diffx = diffx[0]
dx[i] = diffx
else:
raise TypeError("invalid number of arguments")
if edge_order > 2:
raise ValueError("'edge_order' greater than 2 not supported")
# use central differences on interior and one-sided differences on the
# endpoints. This preserves second order-accuracy over the full domain.
outvals = []
# create slice objects --- initially all are [:, :, ..., :]
slice1 = [slice(None)] * ndim
slice2 = [slice(None)] * ndim
slice3 = [slice(None)] * ndim
slice4 = [slice(None)] * ndim
otype = f.dtype
if numpy.issubdtype(otype, numpy.inexact):
pass
else:
# All other types convert to floating point.
# First check if f is a numpy integer type; if so, convert f to float64
# to avoid modular arithmetic when computing the changes in f.
if numpy.issubdtype(otype, numpy.integer):
f = f.astype(numpy.float64)
otype = numpy.float64
for axis, ax_dx in zip(axes, dx):
if f.shape[axis] < edge_order + 1:
raise ValueError(
"Shape of array too small to calculate a numerical gradient, "
"at least (edge_order + 1) elements are required.")
# result allocation
out = cupy.empty_like(f, dtype=otype)
# spacing for the current axis
uniform_spacing = cupy.ndim(ax_dx) == 0
# Numerical differentiation: 2nd order interior
slice1[axis] = slice(1, -1)
slice2[axis] = slice(None, -2)
slice3[axis] = slice(1, -1)
slice4[axis] = slice(2, None)
if uniform_spacing:
out[tuple(slice1)] = (f[tuple(slice4)] -
f[tuple(slice2)]) / (2.0 * ax_dx)
else:
dx1 = ax_dx[0:-1]
dx2 = ax_dx[1:]
dx_sum = dx1 + dx2
a = -(dx2) / (dx1 * dx_sum)
b = (dx2 - dx1) / (dx1 * dx2)
c = dx1 / (dx2 * dx_sum)
# fix the shape for broadcasting
shape = [1] * ndim
shape[axis] = -1
a.shape = b.shape = c.shape = tuple(shape)
# 1D equivalent -- out[1:-1] = a * f[:-2] + b * f[1:-1] + c * f[2:]
out[tuple(slice1)] = (a * f[tuple(slice2)] + b * f[tuple(slice3)] +
c * f[tuple(slice4)])
# Numerical differentiation: 1st order edges
if edge_order == 1:
slice1[axis] = 0
slice2[axis] = 1
slice3[axis] = 0
dx_0 = ax_dx if uniform_spacing else ax_dx[0]
# 1D equivalent -- out[0] = (f[1] - f[0]) / (x[1] - x[0])
out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_0
slice1[axis] = -1
slice2[axis] = -1
slice3[axis] = -2
dx_n = ax_dx if uniform_spacing else ax_dx[-1]
# 1D equivalent -- out[-1] = (f[-1] - f[-2]) / (x[-1] - x[-2])
out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_n
# Numerical differentiation: 2nd order edges
else:
slice1[axis] = 0
slice2[axis] = 0
slice3[axis] = 1
slice4[axis] = 2
if uniform_spacing:
a = -1.5 / ax_dx
b = 2.0 / ax_dx
c = -0.5 / ax_dx
else:
dx1 = ax_dx[0]
dx2 = ax_dx[1]
dx_sum = dx1 + dx2
a = -(2.0 * dx1 + dx2) / (dx1 * (dx_sum))
b = dx_sum / (dx1 * dx2)
c = -dx1 / (dx2 * (dx_sum))
# 1D equivalent -- out[0] = a * f[0] + b * f[1] + c * f[2]
out[tuple(slice1)] = (a * f[tuple(slice2)] + b * f[tuple(slice3)] +
c * f[tuple(slice4)])
slice1[axis] = -1
slice2[axis] = -3
slice3[axis] = -2
slice4[axis] = -1
if uniform_spacing:
a = 0.5 / ax_dx
b = -2.0 / ax_dx
c = 1.5 / ax_dx
else:
dx1 = ax_dx[-2]
dx2 = ax_dx[-1]
dx_sum = dx1 + dx2
a = (dx2) / (dx1 * (dx_sum))
b = -dx_sum / (dx1 * dx2)
c = (2.0 * dx2 + dx1) / (dx2 * (dx_sum))
# 1D equivalent -- out[-1] = a * f[-3] + b * f[-2] + c * f[-1]
out[tuple(slice1)] = (a * f[tuple(slice2)] + b * f[tuple(slice3)] +
c * f[tuple(slice4)])
outvals.append(out)
# reset the slice object in this dimension to ":"
slice1[axis] = slice(None)
slice2[axis] = slice(None)
slice3[axis] = slice(None)
slice4[axis] = slice(None)
if len_axes == 1:
return outvals[0]
else:
return outvals