def amin(a, axis=None, out=None, keepdims=False, dtype=None):
"""Returns the minimum of an array or the minimum along an axis.
.. note::
When at least one element is NaN, the corresponding min value will be
NaN.
Args:
a (cupy.ndarray): Array to take the minimum.
axis (int): Along which axis to take the minimum. The flattened array
is used by default.
out (cupy.ndarray): Output array.
keepdims (bool): If ``True``, the axis is remained as an axis of
size one.
dtype: Data type specifier.
Returns:
cupy.ndarray: The minimum of ``a``, along the axis if specified.
.. seealso:: :func:`numpy.amin`
"""
if fusion._is_fusing():
if keepdims:
raise NotImplementedError(
'cupy.amin does not support `keepdims` in fusion yet.')
return fusion._call_reduction(_statistics.amin,
a, axis=axis, dtype=dtype, out=out)
# TODO(okuta): check type
return a.min(axis=axis, dtype=dtype, out=out, keepdims=keepdims)
def clip(a, a_min=None, a_max=None, out=None):
"""Clips the values of an array to a given interval.
This is equivalent to ``maximum(minimum(a, a_max), a_min)``, while this
function is more efficient.
Args:
a (cupy.ndarray): The source array.
a_min (scalar, cupy.ndarray or None): The left side of the interval.
When it is ``None``, it is ignored.
a_max (scalar, cupy.ndarray or None): The right side of the interval.
When it is ``None``, it is ignored.
out (cupy.ndarray): Output array.
Returns:
cupy.ndarray: Clipped array.
.. seealso:: :func:`numpy.clip`
"""
if fusion._is_fusing():
return fusion._call_ufunc(_math.clip, a, a_min, a_max, out=out)
# TODO(okuta): check type
return a.clip(a_min, a_max, out=out)
def where(condition, x=None, y=None):
"""Return elements, either from x or y, depending on condition.
If only condition is given, return ``condition.nonzero()``.
Args:
condition (cupy.ndarray): When True, take x, otherwise take y.
x (cupy.ndarray): Values from which to choose on ``True``.
y (cupy.ndarray): Values from which to choose on ``False``.
Returns:
cupy.ndarray: Each element of output contains elements of ``x`` when
``condition`` is ``True``, otherwise elements of ``y``. If only
``condition`` is given, return the tuple ``condition.nonzero()``,
the indices where ``condition`` is True.
.. warning::
This function may synchronize the device if both ``x`` and ``y`` are
omitted.
.. seealso:: :func:`numpy.where`
"""
missing = (x is None, y is None).count(True)
if missing == 1:
raise ValueError('Must provide both \'x\' and \'y\' or neither.')
if missing == 2:
return nonzero(condition) # may synchronize
if fusion._is_fusing():
return fusion._call_ufunc(_where_ufunc, condition, x, y)
return _where_ufunc(condition.astype('?'), x, y)
def sum(a, axis=None, dtype=None, out=None, keepdims=False):
"""Returns the sum of an array along given axes.
Args:
a (cupy.ndarray): Array to take sum.
axis (int or sequence of ints): Axes along which the sum is taken.
dtype: Data type specifier.
out (cupy.ndarray): Output array.
keepdims (bool): If ``True``, the specified axes are remained as axes
of length one.
Returns:
cupy.ndarray: The result array.
.. seealso:: :func:`numpy.sum`
"""
if fusion._is_fusing():
if keepdims:
raise NotImplementedError(
'cupy.sum does not support `keepdims` in fusion yet.')
return fusion._call_reduction(_math.sum_auto_dtype,
a,
axis=axis,
dtype=dtype,
out=out)
# TODO(okuta): check type
return a.sum(axis, dtype, out, keepdims)
def copy(a, order='K'):
"""Creates a copy of a given array on the current device.
This function allocates the new array on the current device. If the given
array is allocated on the different device, then this function tries to
copy the contents over the devices.
Args:
a (cupy.ndarray): The source array.
order ({'C', 'F', 'A', 'K'}): Row-major (C-style) or column-major
(Fortran-style) order.
When ``order`` is ``'A'``, it uses ``'F'`` if ``a`` is column-major
and uses ``'C'`` otherwise.
And when ``order`` is ``'K'``, it keeps strides as closely as
possible.
Returns:
cupy.ndarray: The copy of ``a`` on the current device.
.. seealso:: :func:`numpy.copy`, :meth:`cupy.ndarray.copy`
"""
if fusion._is_fusing():
if order != 'K':
raise NotImplementedError(
'cupy.copy does not support `order` in fusion yet.')
return fusion._call_ufunc(core.elementwise_copy, a)
# If the current device is different from the device of ``a``, then this
# function allocates a new array on the current device, and copies the
# contents over the devices.
return a.copy(order=order)
def all(a, axis=None, out=None, keepdims=False):
"""Tests whether all array elements along a given axis evaluate to True.
Args:
a (cupy.ndarray): Input array.
axis (int or tuple of ints): Along which axis to compute all.
The flattened array is used by default.
out (cupy.ndarray): Output array.
keepdims (bool): If ``True``, the axis is remained as an axis of
size one.
Returns:
cupy.ndarray: An array reduced of the input array along the axis.
.. seealso:: :func:`numpy.all`
"""
if fusion._is_fusing():
if keepdims:
raise NotImplementedError(
'cupy.all does not support `keepdims` in fusion yet.')
return fusion._call_reduction(_logic.all, a, axis=axis, out=out)
assert isinstance(a, cupy.ndarray)
return a.all(axis=axis, out=out, keepdims=keepdims)
def copyto(dst, src, casting='same_kind', where=None):
"""Copies values from one array to another with broadcasting.
This function can be called for arrays on different devices. In this case,
casting, ``where``, and broadcasting is not supported, and an exception is
raised if these are used.
Args:
dst (cupy.ndarray): Target array.
src (cupy.ndarray): Source array.
casting (str): Casting rule. See :func:`numpy.can_cast` for detail.
where (cupy.ndarray of bool): If specified, this array acts as a mask,
and an element is copied only if the corresponding element of
``where`` is True.
.. seealso:: :func:`numpy.copyto`
"""
src_type = type(src)
src_is_python_scalar = (src_type in six.integer_types
or src_type in (bool, float, complex)
or src_type is fusion._FusionVarScalar)
if src_is_python_scalar:
src_dtype = numpy.dtype(type(src))
can_cast = numpy.can_cast(src, dst.dtype, casting)
else:
src_dtype = src.dtype
can_cast = numpy.can_cast(src_dtype, dst.dtype, casting)
if not can_cast:
raise TypeError('Cannot cast %s to %s in %s casting mode' %
(src_dtype, dst.dtype, casting))
if fusion._is_fusing():
if where is None:
core.elementwise_copy(src, dst)
else:
fusion._call_ufunc(search._where_ufunc, where, src, dst, dst)
return
if dst.size == 0:
return
if src_is_python_scalar and where is None:
dst.fill(src)
return
if where is None:
if _can_memcpy(dst, src):
dst.data.copy_from(src.data, src.nbytes)
else:
device = dst.device
with device:
if src.device != device:
src = src.copy()
core.elementwise_copy(src, dst)
else:
core.elementwise_copy_where(src, where, dst)
def imag(val):
'''Returns the imaginary part of the elements of the array.
.. seealso:: :func:`numpy.imag`
'''
if fusion._is_fusing():
return fusion._call_ufunc(core.imag, val)
if not isinstance(val, core.ndarray):
val = core.array(val)
return val.imag
def real(val):
'''Returns the real part of the elements of the array.
.. seealso:: :func:`numpy.real`
'''
if fusion._is_fusing():
return fusion._call_ufunc(core.real, val)
if not isinstance(val, core.ndarray):
val = core.array(val)
return val.real
def around(a, decimals=0, out=None):
"""Rounds to the given number of decimals.
Args:
a (cupy.ndarray): The source array.
decimals (int): Number of decimal places to round to (default: 0).
If decimals is negative, it specifies the number of positions to
the left of the decimal point.
out (cupy.ndarray): Output array.
Returns:
cupy.ndarray: Rounded array.
.. seealso:: :func:`numpy.around`
"""
if fusion._is_fusing():
return fusion._call_ufunc(core.core._round_ufunc, a, decimals, out=out)
a = core.array(a, copy=False)
return a.round(decimals, out=out)
