# Source code for mindspore.ops.function.math_func

# Copyright 2022 Huawei Technologies Co., Ltd
#
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# ============================================================================

"""Defines math operators with functional form."""

import math
from itertools import zip_longest
from collections import deque
import numpy as np
import mindspore.ops as ops
from mindspore.common import dtype as mstype
from mindspore.ops.primitive import constexpr
from mindspore.ops import operations as P
from mindspore.ops import composite as C
from mindspore.ops.operations._inner_ops import Cummin
from mindspore.ops.operations.math_ops import STFT
from mindspore.nn import layer
from mindspore._checkparam import check_is_number
from ..operations.math_ops import (
Bernoulli,
BesselJ0,
BesselJ1,
BesselK0,
BesselK0e,
BesselY0,
BesselY1,
BesselK1,
BesselK1e,
MatrixSolve,
Renorm,
Hypot,
Lcm,
Gcd,
SparseSegmentMean,
InplaceUpdateV2,
)
from ...common import dtype as mstype
from ...common.tensor import Tensor
from ..._c_expression import Tensor as Tensor_
from ..._checkparam import Validator as validator
from ..._checkparam import Rel
from .._primitive_cache import _get_cache_prim

@constexpr
def _make_tensor(val, dtype):
"""Returns the tensor with value val and dtype dtype."""
return Tensor(val, dtype)

@constexpr
def get_x_shape(x_shape):
s = 1
for i in x_shape:
s = s * i
return (s,)

#####################################
# Public Operation Functions.
#####################################
absolute = P.Abs()
tensor_ceil = P.Ceil()
neg_tensor = P.Neg()
tensor_sub = P.Sub()
tensor_mul = P.Mul()
tensor_div = P.RealDiv()
tensor_floordiv = P.FloorDiv()
floordiv = tensor_floordiv
xdivy_ = P.Xdivy()
tensor_pow = P.Pow()
pows = tensor_pow
tensor_mod = P.FloorMod()
floormod = tensor_mod
tensor_exp = P.Exp()
tensor_expm1 = P.Expm1()
tensor_lt = P.Less()
tensor_le = P.LessEqual()
tensor_gt = P.Greater()
tensor_ge = P.GreaterEqual()
not_equal = P.NotEqual()

#####################################
# Private Operation Functions.
#####################################
log_ = P.Log()
floor_ = P.Floor()
logical_not_ = P.LogicalNot()
logical_or_ = P.LogicalOr()
logical_and_ = P.LogicalAnd()
sin_ = P.Sin()
cos_ = P.Cos()
tan_ = P.Tan()
asin_ = P.Asin()
acos_ = P.ACos()
atan_ = P.Atan()
sinh_ = P.Sinh()
cosh_ = P.Cosh()
tanh_ = P.Tanh()
asinh_ = P.Asinh()
acosh_ = P.Acosh()
atanh_ = P.Atanh()
bitwise_and_ = P.BitwiseAnd()
bitwise_or_ = P.BitwiseOr()
bitwise_xor_ = P.BitwiseXor()
inv_ = P.math_ops.Inv()
invert_ = P.Invert()
erf_ = P.Erf()
erfc_ = P.Erfc()
bessel_j1_ = BesselJ1()
bessel_j0_ = BesselJ0()
bessel_i0_ = P.BesselI0()
bessel_i0e_ = P.BesselI0e()
bessel_k0_ = BesselK0()
bessel_k0e_ = BesselK0e()
bessel_y0_ = BesselY0()
bessel_y1_ = BesselY1()
bessel_i1_ = P.BesselI1()
bessel_i1e_ = P.BesselI1e()
bessel_k1_ = BesselK1()
bessel_k1e_ = BesselK1e()
equal_ = P.Equal()
isfinite_ = P.IsFinite()
isnan_ = P.IsNan()
same_type_shape_ = P.SameTypeShape()
maximum_ = P.Maximum()
minimum_ = P.Minimum()
lerp_ = P.Lerp()
tensor_round_ = P.Round()
linspace_ = P.LinSpace()
matrix_determinant_ = P.MatrixDeterminant()
log_matrix_determinant_ = P.LogMatrixDeterminant()
exp2_ = P.Pow()
truncate_div_ = P.TruncateDiv()
truncate_mod_ = P.TruncateMod()
trunc_ = P.Trunc()
sparse_segment_mean_ = SparseSegmentMean()
xlogy_ = P.Xlogy()

#####################################
# Element-wise Operation Functions.
#####################################

"""
Computes addition of all input tensors element-wise.

All input tensors must have the same shape.

Args:
x (Union(tuple[Tensor], list[Tensor])): A tuple or list composed of Tensor, the data type is
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ .

Returns:
Tensor, has the same shape and dtype as each Tensor of x.

Raises:
TypeError: If x is neither tuple nor list.
ValueError: If there are Tensors with different shapes in x.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> y = Tensor(np.array([4, 5, 6]), mindspore.float32)
>>> output = ops.addn([x, y, x, y])
>>> print(output)
[10. 14. 18.]
"""

[文档]def abs(x):
r"""
Returns absolute value of a tensor element-wise.

.. math::

out_i = |x_i|

Args:
x (Tensor): The input tensor. The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape as the x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([-1.0, 1.0, 0.0]), mindspore.float32)
>>> output = ops.abs(x)
>>> print(output)
[1. 1. 0.]
"""
return absolute(x)

r"""

.. math::

out_{i} = x_{i} + y_{i}

.. note::
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one of the input x , y after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, number.Number, bool.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> # case 1: x and y are both Tensor.
>>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
>>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
>>> print(output)
[5. 7. 9.]
>>> # case 2: x is a scalar and y is a Tensor
>>> x = Tensor(1, mindspore.int32)
>>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
>>> print(output)
[5. 6. 7.]
>>> # the data type of x is int32, the data type of y is float32,
>>> # and the output is the data format of higher precision float32.
>>> print(output.dtype)
Float32
"""

def exp2(x):
"""
Computes the base two exponential function of input.

Calculates 2^x.

Args:
x (Tensor): Input tensor.

Returns:
Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([2, 3, 4]), mindspore.float32)
>>> output = ops.exp2(x)
>>> print(output)
[ 4.  8. 16.]
"""

tensor_2 = Tensor(np.array(2.0).astype(np.float32))
if x.dtype == mstype.float16:
tensor_2 = Tensor(np.array(2.0).astype(np.float16))
return exp2_(tensor_2, x)

[文档]def argmin(x, axis=-1):
"""
Returns the indices of the minimum value of a tensor across the axis.

If the shape of input tensor is :math:(x_1, ..., x_N), the shape of the output tensor is
:math:(x_1, ..., x_{axis-1}, x_{axis+1}, ..., x_N).

Args:
x (Tensor): Input tensor. The shape is :math:(N,*) where :math:* means, any number of additional dimensions.
axis (int): Axis where the Argmin operation applies to. Default: -1.

Returns:
Tensor, indices of the min value of input tensor across the axis.

Raises:
TypeError: If axis is not an int.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input_x = Tensor(np.array([2.0, 3.1, 1.2]), mindspore.float32)
>>> index = ops.argmin(input_x)
>>> print(index)
2
"""
_argmin = _get_cache_prim(P.Argmin)(axis)
return _argmin(x)

neg_tensor = P.Neg()

[文档]def neg(x):
"""
Returns a tensor with negative values of the input tensor element-wise.

.. math::

out_{i} = - x_{i}

Args:
x (Tensor): The input tensor with a dtype of Number, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape and dtype as input.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, -1, 2, 0, -3.5]), mindspore.float32)
>>> output = ops.neg(x)
>>> print(output)
[-1.  -2.   1.  -2.   0.   3.5]
"""
return neg_tensor(x)

[文档]def ceil(x):
r"""
Rounds a tensor up to the closest integer element-wise.

.. math::

out_i = \lceil x_i \rceil = \lfloor x_i \rfloor + 1

Args:
x (Tensor): The input tensor with a dtype of float16 or float32, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16 or float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> from mindspore.ops import functional as F
>>> x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
>>> output = F.ceil(x)
>>> print(output)
[ 2.  3. -1.]
"""
return tensor_ceil(x)

[文档]def round(x):
r"""
Returns half to even of a tensor element-wise.

.. math::

out_i \approx x_i

Args:
x (Tensor): The input tensor.

Returns:
Tensor, has the same shape and type as the x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
>>> output = ops.round(x)
>>> print(output)
[ 1.  2.  2.  2. -4.]
"""
return tensor_round_(x)

[文档]def sub(x, y):
r"""
Subtracts the second input tensor from the first input tensor element-wise.

.. math::

out_{i} = x_{i} - y_{i}

.. note::
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not a number.Number or a bool or a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([4, 5, 6]), mindspore.int32)
>>> output = ops.sub(x, y)
>>> print(output)
[-3 -3 -3]
"""
return tensor_sub(x, y)

[文档]def mul(x, y):
r"""
Multiplies two tensors element-wise.

.. math::

out_{i} = x_{i} * y_{i}
.. note::
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, number.Number, bool.
ValueError: If x and y are not the same shape.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
>>> output = ops.mul(x, y)
>>> print(output)
[ 4. 10. 18.]
"""
return tensor_mul(x, y)

[文档]def div(x, y):
"""
Divides the first input tensor by the second input tensor in floating-point type element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. math::

out_{i} = x_{i} / y_{i}

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
>>> output = ops.div(x, y)
>>> print(output)
[0.25 0.4  0.5 ]
"""
return tensor_div(x, y)

[文档]def floor_div(x, y):
"""
Divides the first input tensor by the second input tensor element-wise and round down to the closest integer.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. math::

out_{i} = \\text{floor}( \\frac{x_i}{y_i})

where the :math:floor indicates the Floor operator, for more details, please refer to the Floor operator.

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
>>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> output = ops.floor_div(x, y)
>>> print(output)
[ 0  1 -1]
"""
return tensor_floordiv(x, y)

[文档]def pow(x, y):
r"""
Calculates the y power of each element in x.

.. math::

out_{i} = x_{i} ^{ y_{i}}

.. note::
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, number.Number or bool.
ValueError: If the shape of x and y are different.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> y = 3.0
>>> output = ops.pow(x, y)
>>> print(output)
[ 1.  8. 64.]
>>>
>>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> y = Tensor(np.array([2.0, 4.0, 3.0]), mindspore.float32)
>>> output = ops.pow(x, y)
>>> print(output)
[ 1. 16. 64.]
"""
return tensor_pow(x, y)

[文档]def floor_mod(x, y):
r"""
Computes the remainder of division element-wise. It's a flooring divide.
E.g. :math:floor(x / y) * y + mod(x, y) = x.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be both bool, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. math::

out_{i} =\text{floor}(x_{i} // y_{i})

where the :math:floor indicates the Floor operator, for more details, please refer to the Floor operator.

.. warning::
- The input data does not support 0.
- When the elements of input exceeds 2048 , the accuracy of operator cannot guarantee the requirement of
double thousandths in the mini form.
- Due to different architectures, the calculation results of this operator on NPU and CPU may be inconsistent.
- If shape is expressed as (D1,D2... ,Dn), then D1\*D2... \*DN<=1000000,n<=8.

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision of the two inputs.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
>>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> output = ops.floor_mod(x, y)
>>> print(output)
[2 1 2]
"""
return tensor_mod(x, y)

[文档]def exp(x):
r"""
Returns exponential of a tensor element-wise.

.. math::

out_i = e^{x_i}

Args:
x (Tensor): The input tensor, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> output = ops.exp(x)
>>> print(output)
[ 2.718282  7.389056 54.598152]
"""
return tensor_exp(x)

[文档]def expm1(x):
r"""
Returns exponential then minus 1 of a tensor element-wise.

.. math::

out_i = e^{x_i} - 1

Args:
x (Tensor): The input tensor with a dtype of float16 or float32, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is neither float16 nor float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.0, 1.0, 2.0, 4.0]), mindspore.float32)
>>> output = ops.expm1(x)
>>> print(output)
[ 0.        1.718282  6.389056 53.598152]
"""
return tensor_expm1(x)

[文档]def log(x):
"""
Returns the natural logarithm of a tensor element-wise.

.. math::
y_i = log_e(x_i)

.. note::
The dimension of the input Tensor on Ascend should be less than or equal to 8, and the dimension of the
input Tensor on the CPU should be less than 8.

.. warning::
If the input value of operator Log is within the range (0, 0.01] or [0.95, 1.05], the output accuracy may
be affacted.

Args:
x (Tensor): Input Tensor of any dimension. The value must be greater than 0.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64 on GPU and CPU.
TypeError: If dtype of x is not float16 or float32 on Ascend.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> output = ops.log(x)
>>> print(output)
[0.        0.6931472 1.3862944]
"""
return log_(x)

[文档]def floor(x):
r"""
Rounds a tensor down to the closest integer element-wise.

.. math::

out_i = \lfloor x_i \rfloor

Args:
x (Tensor): The input tensor, its rank must be in [0, 7] inclusive
and data type must be float16, float32 or float64.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not in [float16, float32, float64].

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
>>> output = ops.floor(x)
>>> print(output)
[ 1.  2. -2.]
"""
return floor_(x)

[文档]def inplace_update(x, v, indices):
"""
Updates specified rows with values in v.

Note:
indices refers to the left-most dimension.

Args:
indices (Union[int, tuple], Tensor): Indices into the left-most dimension of x, and determines which rows of x
to update with v. It is an int or tuple, whose value is in [0, the first dimension size of x). If the type
is Tensor, it supports dynamic shape. Otherwise, it only supports static shape.
x (Tensor): A tensor which to be inplace updated. It can be one of the following data types:
float32, float16 and int32.
v (Tensor): A tensor with the same type as x and the same dimension size as x except
the first dimension, which must be the same as the size of indices.

Returns:
Tensor, with the same type and shape as the input x.

Raises:
TypeError: If indices is neither int nor tuple.
TypeError: If indices is a tuple and its element is not an int.

Supported Platforms:
Ascend CPU

Examples:
>>> indices = (0, 1)
>>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
>>> v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
>>> output = ops.inplace_update(x, v, indices)
>>> print(output)
[[0.5 1. ]
[1.  1.5]
[5.  6. ]]
"""
if not isinstance(indices, (Tensor, Tensor_)):
inplace_update_inner = _get_cache_prim(P.InplaceUpdate)(indices)
output = inplace_update_inner(x, v)
else:
inplace_update_inner = InplaceUpdateV2()
output = inplace_update_inner(x, indices, v)
return output

"""
Adds v into specified rows of x. Computes y = x; y[i,] += v.

Note:
indices refers to the left-most dimension.

Args:
indices (Union[int, tuple]): Indices into the left-most dimension of x, and determines which rows of x
to add with v. It is an integer or a tuple, whose value is in [0, the first dimension size of x).
x (Tensor): The first input is a tensor whose data type is float16, float32, float64 or int32.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
v (Tensor): The second input is a tensor that has the same dimension sizes as x except
the first dimension, which must be the same as indices' size. It has the same data type with x.

Returns:
Tensor, has the same shape and dtype as x.

Raises:
TypeError: If indices is neither int nor tuple.
TypeError: If indices is a tuple whose elements are not all int.
ValueError: If the rank of x is not equal to the rank of v.
ValueError: If the length of indices is not equal to v.shape[0].
ValueError: If the values of indices are not in range of [0, x.shape[0]).

Supported Platforms:
Ascend CPU

Examples:
>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor, ops
>>> indices = (0, 1)
>>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
>>> input_v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
>>> output = ops.inplace_add(x, input_v, indices)
>>> print(output)
[[1.5 3. ]
[4.  5.5]
[5.  6. ]]
"""

[文档]def inplace_sub(x, v, indices):
"""
Subtracts v into specified rows of x. Computes y = x; y[i,] -= v.

Note:
indices refers to the left-most dimension.

Args:
indices (Union[int, tuple]): Indices into the left-most dimension of x, and determines which rows of x
to subtract with v. It is an int or tuple, whose value is in [0, the first dimension size of x).
x (Tensor): The first input is a tensor whose data type is float16, float32, float64 or int32.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
v (Tensor): The second input is a tensor who has the same dimension sizes as x except
the first dimension, which must be the same as indices' size. It has the same data type with x.

Returns:
Tensor, has the same shape and dtype as x.

Raises:
TypeError: If indices is neither int nor tuple.
TypeError: If indices is a tuple whose elements are not all int.
ValueError: If the rank of x is not equal to the rank of v.
ValueError: If the length of indices is not equal to v.shape[0].
ValueError: If the values of indices are not in range of [0, x.shape[0]).

Supported Platforms:
Ascend CPU

Examples:
>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor, ops
>>> indices = (0, 1)
>>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
>>> input_v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
>>> output = ops.inplace_sub(x, input_v, indices)
>>> print(output)
[[0.5 1. ]
[2.  2.5]
[5.  6. ]]
"""
inplace_sub_inner = _get_cache_prim(P.InplaceSub)(indices)
return inplace_sub_inner(x, v)

[文档]def logical_not(x):
"""
Computes the "logical NOT" of a tensor element-wise.

.. math::

out_{i} = \\neg x_{i}

Args:
x (Tensor): The input tensor whose dtype is bool.
:math:(N,*) where :math:* means,any number of additional dimensions.

Returns:
Tensor, the shape is the same as the x, and the dtype is bool.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not a bool.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> output = ops.logical_not(x)
>>> print(output)
[False  True False]
"""
return logical_not_(x)

[文档]def logical_or(x, y):
"""
Computes the "logical OR" of two tensors element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one bool.
When the inputs are two tensors, the shapes of them could be broadcast,
and the data types of them must be bool.
When the inputs are one tensor and one bool, the bool object could only be a constant,
and the data type of the tensor must be bool.

.. math::

out_{i} = x_{i} \\vee y_{i}

Note:

Args:
x (Union[Tensor, bool]): The first input is a bool or a tensor whose data type is bool.
y (Union[Tensor, bool]): The second input is a bool when the first input is a tensor or
a tensor whose data type is bool.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> y = Tensor(np.array([True, True, False]), mindspore.bool_)
>>> output = ops.logical_or(x, y)
>>> print(output)
[ True  True  True]
"""
return logical_or_(x, y)

[文档]def logical_and(x, y):
r"""
Computes the "logical AND" of two tensors element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one bool.
When the inputs are two tensors, the shapes of them could be broadcast,
and the data types of them must be bool.
When the inputs are one tensor and one bool, the bool object could only be a constant,
and the data type of the tensor must be bool.

.. math::

out_{i} = x_{i} \wedge y_{i}

Note:

Args:
x (Union[Tensor, bool]): The first input is a bool or a tensor whose data type is bool.
y (Union[Tensor, bool]): The second input is a bool when the first input is a tensor or
a tensor whose data type is bool.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> y = Tensor(np.array([True, True, False]), mindspore.bool_)
>>> output = ops.logical_and(x, y)
>>> print(output)
[ True False False]
"""
return logical_and_(x, y)

[文档]def sin(x):
r"""
Computes sine of the input element-wise.

.. math::

out_i = sin(x_i)

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
>>> output = ops.sin(x)
>>> print(output)
[0.5810352 0.27635565 0.41687083 0.5810352]
"""
return sin_(x)

[文档]def cos(x):
r"""
Computes cosine of input element-wise.

.. math::
out_i = cos(x_i)

.. warning::
Currently support Float16, Float32 data type. If use Float64, there may
be a problem of missing precision.

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
>>> output = ops.cos(x)
>>> print(output)
[0.971338 0.6748758 0.95233357 0.9959527]
"""
return cos_(x)

[文档]def tan(x):
r"""
Computes tangent of x element-wise.

.. math::

out_i = tan(x_i)

Args:
x (Tensor): The input Tensor, valid for any dimensions.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend CPU GPU

Examples:
>>> x = Tensor(np.array([-1.0, 0.0, 1.0]), mindspore.float32)
>>> output = ops.tan(x)
>>> print(output)
[-1.5574081 0. 1.5574081]
"""
return tan_(x)

[文档]def xlogy(x, y):
r"""
Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
Returns zero when x is zero.

.. math::

out_i = x_{i}\ln{y_{i}}

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. warning::
- On Ascend, the data type of x and y must be float16 or float32.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input is a number.Number or
a bool when the first input is a tensor or a tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not a number.Number or a bool or a Tensor.
TypeError: If dtype of x and 'y' is not in [float16, float32, float64, complex64, complex128].
ValueError: If x could not be broadcast to a tensor with shape of y.

Supported Platforms:
Ascend CPU

Examples:
>>> x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
>>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
>>> output = ops.xlogy(x, y)
>>> print(output)
[-3.465736   0.        2.7725887]
"""
return xlogy_(x, y)

[文档]def asin(x):
r"""
Computes arcsine of input tensors element-wise.

.. math::

out_i = sin^{-1}(x_i)

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.
The data type should be one of the following types: float16, float32, float64.

Returns:
Tensor, has the same shape and dtype as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32, float64.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
>>> output = ops.asin(x)
>>> print(output)
[0.8330704  0.04001067 0.30469266 0.5943858 ]
"""
return asin_(x)

[文档]def acos(x):
r"""
Computes arccosine of input tensors element-wise.

.. math::

out_i = cos^{-1}(x_i)

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.
The data type should be one of the following types: float16, float32, float64.

Returns:
Tensor, has the same shape and dtype as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
>>> output = ops.acos(x)
>>> print(output)
[0.737726  1.5307857 1.2661036 0.9764105]
"""
return acos_(x)

[文档]def atan(x):
r"""
Computes the trigonometric inverse tangent of the input element-wise.

.. math::

out_i = tan^{-1}(x_i)

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.
The data type should be one of the following types: float16, float32.

Returns:
A Tensor, has the same type as the input.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16 or float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 0.0]), mindspore.float32)
>>> output = ops.atan(x)
>>> print(output)
[0.7853982 0.       ]
"""
return atan_(x)

[文档]def sinh(x):
r"""
Computes hyperbolic sine of the input element-wise.

.. math::

out_i = \sinh(x_i)

Args:
x (Tensor): The input tensor of hyperbolic sine function, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
>>> output = ops.sinh(x)
>>> print(output)
[0.6604918  0.28367308 0.44337422 0.6604918 ]
"""
return sinh_(x)

[文档]def cosh(x):
r"""
Computes hyperbolic cosine of input element-wise.

.. math::

out_i = \cosh(x_i)

Args:
x (Tensor): The input tensor of hyperbolic cosine function, its rank must be in [0, 7] inclusive
and data type must be float16, float32, float64, complex64 or complex128.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If the dtype of x is not one of the following types:
float16, float32, float64, complex64, complex128.
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
>>> output = ops.cosh(x)
>>> print(output)
[1.0289385 1.364684 1.048436 1.0040528]
"""
return cosh_(x)

[文档]def tanh(input_x):
r"""
Tanh activation function.

Computes hyperbolic tangent of input element-wise. The Tanh function is defined as:

.. math::

tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},

where :math:x_i is an element of the input Tensor.

Args:
input_x (Tensor): Tensor of shape :math:(N, *), where :math:* means, any number of
additional dimensions, with float16 or float32 data type.

Returns:
Tensor, with the same type and shape as the input_x.

Raises:
TypeError: If dtype of input_x is neither float16 nor float32.
TypeError: If input_x is not a Tensor.

Supported Platforms:
Ascend GPU  CPU

Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> output = ops.tanh(input_x)
>>> print(output)
[0.7615941 0.9640276 0.9950547 0.9993293 0.9999092]
"""
return tanh_(input_x)

[文档]def asinh(x):
r"""
Computes inverse hyperbolic sine of the input element-wise.

.. math::

out_i = \sinh^{-1}(input_i)

Args:
x (Tensor): The input tensor of inverse hyperbolic sine function, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape and type as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
>>> output = ops.asinh(x)
>>> print(output)
[-2.3124382  1.1947632  1.8184465  5.298342 ]
"""
return asinh_(x)

[文档]def acosh(x):
r"""
Computes inverse hyperbolic cosine of the inputs element-wise.

.. math::

out_i = \cosh^{-1}(input_i)

.. warning::
Given an input tensor x, the function computes inverse hyperbolic cosine of every element.
Input range is [1, inf].

Args:
x (Tensor): The input tensor of inverse hyperbolic cosine function, its rank must be in [0, 7] inclusive.

Returns:
Tensor, has the same shape and type as x.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
>>> output = ops.acosh(x)
>>> print(output)
[0.        0.9624237 1.7627472 5.298292 ]
"""
return acosh_(x)

[文档]def atanh(x):
r"""
Computes inverse hyperbolic tangent of the input element-wise.

.. math::

out_i = \tanh^{-1}(x_{i})

.. warning::
This is an experimental prototype that is subject to change and/or deletion.

Args:
x (Tensor): The shape of tensor is
:math:(N,*) where :math:* means, any number of additional dimensions.
The data type should be one of the following types: float16, float32.

Returns:
A Tensor, has the same type as the input.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16 or float32.

Supported Platforms:
Ascend CPU

Examples:
>>> x = Tensor(np.array([0, -0.5]), mindspore.float32)
>>> output = ops.atanh(x)
>>> print(output)
[ 0.         -0.54930615]
"""
return atanh_(x)

[文档]def atan2(x, y):
r"""
Returns arctangent of x/y element-wise.

It returns :math:\theta\ \in\ [-\pi, \pi]
such that :math:x = r*\sin(\theta), y = r*\cos(\theta), where :math:r = \sqrt{x^2 + y^2}.

Args of x and y comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, the lower precision data type will be converted to
the relatively highest precision data type.

Args:
x (Tensor): The input tensor.
:math:(N,*) where :math:* means, any number of additional dimensions.
y (Tensor): The input tensor. It has the same shape with x.

Returns:
Tensor, the shape is the same as the one after broadcasting,and the data type is same as x.

Raises:
TypeError: If x or y is not a Tensor.
RuntimeError: If the data type of x and y conversion of Parameter is required
when data type conversion of Parameter is not supported.

Supported Platforms:
Ascend CPU GPU

Examples:
>>> x = Tensor(np.array([0, 1]), mindspore.float32)
>>> y = Tensor(np.array([1, 1]), mindspore.float32)
>>> output = ops.atan2(x, y)
>>> print(output)
[0.        0.7853982]
"""
_atan2 = _get_cache_prim(P.Atan2)()
return _atan2(x, y)

[文档]def bitwise_and(x, y):
r"""
Returns bitwise and of two tensors element-wise.

.. math::

out_i = x_{i} \wedge y_{i}

Args of x and y comply with the implicit type conversion rules to
make the data types consistent.
If they have different data types, the lower priority data type will be converted to
the relatively highest priority data type.

Args:
x (Tensor): The input tensor with int16, int32 or uint16 data type.
:math:(N,*) where :math:* means, any number of additional dimensions.
y (Tensor): The input tensor with same type as the x.

Returns:
Tensor, has the same type as the x.

Raises:
TypeError: If x or y is not a Tensor.
RuntimeError: If the data type of x and y conversion of Parameter is required
when data type conversion of Parameter is not supported.

Supported Platforms:
Ascend CPU

Examples:
>>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
>>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
>>> output = ops.bitwise_and(x, y)
>>> print(output)
[ 0  0  1 -1  1  0  1]
"""
return bitwise_and_(x, y)

[文档]def bitwise_or(x, y):
r"""
Returns bitwise or of two tensors element-wise.

.. math::

out_i = x_{i} \mid y_{i}

Args of x and y comply with the implicit type conversion rules to
make the data types consistent.
If they have different data types, the lower priority data type will be converted to
the relatively highest priority data type.

Args:
x (Tensor): The input tensor with int16, int32 or uint16 data type.
y (Tensor): The input tensor with same type as the x.

Returns:
Tensor, has the same type as the x.

Raises:
TypeError: If x or y is not a Tensor.
RuntimeError: If the data type of x, y conversion of Parameter is required
when data type conversion of Parameter is not supported.

Supported Platforms:
Ascend CPU

Examples:
>>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
>>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
>>> output = ops.bitwise_or(x, y)
>>> print(output)
[ 0  1  1 -1 -1  3  3]
"""
return bitwise_or_(x, y)

[文档]def bitwise_xor(x, y):
r"""
Returns bitwise xor of two tensors element-wise.

.. math::

out_i = x_{i} \oplus y_{i}

Args of x and y comply with the implicit type conversion rules to
make the data types consistent.
If they have different data types, the lower priority data type will be converted to
the relatively highest priority data type.

Args:
x (Tensor): The input tensor with int16, int32 or uint16 data type.
y (Tensor): The input tensor with same type as the x.

Returns:
Tensor, has the same type as the x.

Raises:
TypeError: If x or y is not a Tensor.
RuntimeError: If the data type of x, y conversion of Parameter is required
when data type conversion of Parameter is not supported.

Supported Platforms:
Ascend CPU

Examples:
>>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
>>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
>>> output = ops.bitwise_xor(x, y)
>>> print(output)
[ 0  1  0  0 -2  3  2]
"""
return bitwise_xor_(x, y)

[文档]def inv(x):
r"""
Computes Reciprocal of input tensor element-wise.

.. math::
out_i = \frac{1}{x_{i} }

Args:
x (Tensor): Tensor of any dimension. Must be one of the following types: float16, float32 or int32.

Returns:
Tensor, has the same type and shape as input shape value.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not one of float16, float32, int32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> from mindspore.ops import functional as F
>>> x = Tensor(np.array([0.25, 0.4, 0.31, 0.52]), mindspore.float32)
>>> output = F.inv(x)
>>> print(output)
[4.        2.5       3.2258065 1.923077 ]
"""
return inv_(x)

[文档]def invert(x):
r"""
Flips all bits of input tensor element-wise.

.. math::
out_i = \sim x_{i}

Args:
x (Tensor): The shape of tensor is :math:(x_1, x_2, ..., x_R).
The data type should be one of the following types: int16, uint16.

Returns:
Tensor, has the same shape as x.

Raises:
TypeError: If dtype of x is neither int16 nor uint16.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> from mindspore.ops import functional as F
>>> x = Tensor(np.array([25, 4, 13, 9]), mindspore.int16)
>>> output = F.invert(x)
>>> print(output)
[-26 -5 -14 -10]
"""
return invert_(x)

[文档]def erf(x):
r"""
Computes the Gauss error function of x element-wise.

.. math::

erf(x)=\frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt

Args:
x (Tensor): The input tensor of Gaussian error function. Its rank must be in [0, 7] inclusive
and data type must be float16 or float32.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is neither float16 nor float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
>>> output = ops.erf(x)
>>> print(output)
[-0.8427168   0.          0.8427168   0.99530876  0.99997765]
"""
return erf_(x)

[文档]def erfc(x):
r"""
Computes the complementary error function of x element-wise.

.. math::

erfc(x) = 1 - \frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt

Args:
x (Tensor): The input tensor with a dtype of float16 or float32,
its rank should be in [0, 7] inclusive.

Returns:
Tensor, has the same shape and dtype as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16 or float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
>>> output = ops.erfc(x)
>>> print(output)
[1.8427168e+00 1.0000000e+00 1.5728319e-01 4.6912432e-03 2.2351742e-05]
"""
return erfc_(x)

[文档]def bessel_j0(x):
r"""
Computes the Bessel j0 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_j0(x)
>>> print(output)
[0.93846981 0.76519769 0.22389078 -0.39714981]
"""
return bessel_j0_(x)

[文档]def bessel_j1(x):
r"""
Computes the Bessel j1 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_j1(x)
>>> print(output)
[0.24226846  0.44005059  0.57672481 -0.06604333]
"""
return bessel_j1_(x)

[文档]def bessel_i0(x):
r"""
Computes the Bessel i0 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([-1, -0.5, 0.5, 1]), mindspore.float32)
>>> output = ops.bessel_i0(x)
>>> print(output)
[1.26606588  1.06348337  1.06348337  1.26606588]
"""
return bessel_i0_(x)

[文档]def bessel_i0e(x):
r"""
Computes the Bessel i0e function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU GPU

Examples:
>>> x = Tensor(np.array([-1, -0.5, 0.5, 1]), mindspore.float32)
>>> output = ops.bessel_i0e(x)
>>> print(output)
[0.46575961  0.64503527  0.64503527  0.46575961]
"""
return bessel_i0e_(x)

[文档]def bessel_k0(x):
r"""
Computes the Bessel k0 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_k0(x)
>>> print(output)
[0.92441907  0.42102444  0.11389387  0.01115968]
"""
return bessel_k0_(x)

[文档]def bessel_k0e(x):
r"""
Computes the Bessel k0e function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_k0e(x)
>>> print(output)
[1.52410939  1.14446308  0.84156822  0.60929767]
"""
return bessel_k0e_(x)

[文档]def bessel_y0(x):
r"""
Computes the Bessel y0 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_y0(x)
>>> print(output)
[-0.44451874  0.08825696  0.51037567  -0.01694074]
"""
return bessel_y0_(x)

[文档]def bessel_y1(x):
r"""
Computes the Bessel y1 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_y1(x)
>>> print(output)
[-1.47147239  -0.78121282  -0.10703243  0.39792571]
"""
return bessel_y1_(x)

[文档]def linspace(start, stop, num):
r"""
Returns a Tensor whose value is num evenly spaced in the interval start and stop (including start and
stop), and the length of the output Tensor is num.

.. math::
\begin{aligned}
&step = (stop - start)/(num - 1)\\
&output = [start, start+step, start+2*step, ... , stop]
\end{aligned}

Args:
start (Tensor): Start value of interval. The tensor data type must be float32 and with shape of 0-D.
stop (Tensor): Last value of interval. The tensor data type must be float32 and with shape of 0-D.
num (int): Number of ticks in the interval, inclusive of start and stop.
Must be positive int number.

Returns:
Tensor, has the same dtype as start, and the shape of :math:(num)

Raises:
TypeError: If start or stop is not a Tensor.
TypeError: If dtype of start or dtype of stop is not float32.
ValueError: If shape of start or shape of stop is not 0-D.
TypeError: If num is not int.
ValueError: If num is not positive int number.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> start = Tensor(1, mindspore.float32)
>>> stop = Tensor(10, mindspore.float32)
>>> num = 5
>>> output = ops.linspace(start, stop, num)
>>> print(output)
[ 1.    3.25  5.5   7.75 10.  ]
"""
return linspace_(start, stop, num)

def matrix_determinant(x):
r"""
Computes the determinant of one or more square matrices.

Args:
x (Tensor): A matrix to be calculated. The matrix must be at least two dimensions, and the last two
dimensions must be the same size. Data type must be float32, float64, complex64 or complex128.

Returns:
Tensor, The shape is :math:x\_shape[:-2], the dtype is same as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x not float32, float64, complex64 or complex128.
ValueError: If the last two dimensions of x is not same size.
ValueError: If the dimension of x is less than 2.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input_x = Tensor(np.array([[[-4.5, -1.5], [7.0, 6.0]], [[2.5, 0.5], [3.0, 9.0]]]), mindspore.float32)
>>> output = ops.matrix_determinant(input_x)
>>> print(output)
[-16.5 21. ]
"""
return matrix_determinant_(x)

def log_matrix_determinant(x):
r"""
Computes the sign and the log of the absolute value of the determinant of one or more square matrices.

Args:
x (Tensor): A matrix to be calculated. The matrix must be at least two dimensions, and the last two
dimensions must be the same size. Data type must be float32, float64, complex64 or complex128.

Returns:
Tensor, The signs of the log determinants. The shape is :math:x\_shape[:-2], the dtype is same as x.

Tensor, The absolute values of the log determinants. The shape is :math:x\_shape[:-2],
the dtype is same as x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x not float32, float64, complex64 or complex128.
ValueError: If the last two dimensions of x is not same size.
ValueError: If the dimension of x is less than 2.

Supported Platforms:
GPU CPU

Examples:
>>> input_x = Tensor(np.array([[[-4.5, -1.5], [7.0, 6.0]], [[2.5, 0.5], [3.0, 9.0]]]), mindspore.float32)
>>> sign, output = op(input_x)
>>> print(sign)
[-1.   1.]
>>> print(output)
[2.80336046e+00    3.04452229e+00]
"""
return log_matrix_determinant_(x)

r"""
Solves systems of linear equations.

.. math::
\begin{aligned}
&matrix[..., M, M] * x[..., M, K] = rhs[..., M, K] \\
&adjoint(matrix[..., M, M]) * x[..., M, K] = rhs[..., M, K]
\end{aligned}

.. warning::
On GPU, if the matrix is irreversible, an error may be reported or an unknown result may be returned.

Args:
matrix (Tensor): The shape of tensor is :math:[..., M, M].
rhs (Tensor): The shape of tensor is :math:[..., M, K]. rhs must have the same dtype as matrix.
adjoint(bool): Indicating whether to solve with matrix or its (block-wise) adjoint. Default: False.

Returns:
x (Tensor): The dtype and shape is the same as 'rhs'.

Raises:
TypeError: If adjoint is not the type of bool.
TypeError: If the type of matrix is not one of the following dtype:
mstype.float16, mstype.float32, mstype.float64, mstype.complex64, mstype.complex128.
TypeError: If the type of matrix is not the same as that of rhs.
ValueError: If the rank of matrix less than 2.
ValueError: If the dimension of matrix is not the same as rhs.
ValueError: If the inner-most 2 dimension of matrix is not the same.
ValueError: If the inner-most 2 dimension of rhs does not match matrix.
ValueError: If the matrix is irreversible.

Supported Platforms:
GPU CPU

Examples:
>>> matrix = Tensor([[5, 4], [3, 1]], mindspore.float32)
>>> rhs = Tensor([[7], [2]], mindspore.float32)
>>> result = ops.matrix_solve(matrix, rhs)
>>> print(result)
[[0.14285707]
[1.5714287 ]]
"""
return matrix_solve_(matrix, rhs)

[文档]def truncate_div(x, y):
"""
Divides the first input tensor by the second input tensor element-wise for integer types, negative numbers will
round fractional quantities towards zero.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

Note:

Args:
x(Union[Tensor, Number, bool]): The first input is a number, or a bool,
or a tensor whose data type is number or bool.
y(Union[Tensor, Number, bool]): The second input is a number, or a bool when the first input
is a tensor, or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.

Supported Platforms:
Ascend CPU GPU

Examples:
>>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
>>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> output = ops.truncate_div(x, y)
>>> print(output)
[0 1 0]
"""
return truncate_div_(x, y)

[文档]def truncate_mod(x, y):
r"""
Returns the remainder of division element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. warning::
- The input data does not support 0.
- When the elements of input exceed 2048 , the accuracy of operator cannot guarantee the requirement of
double thousandths in the mini form.
- Due to different architectures, the calculation results of this operator on NPU and CPU may be inconsistent.
- If shape is expressed as (D1,D2... ,Dn), then D1\*D2... \*DN<=1000000,n<=8.

Args:
x (Union[Tensor, numbers.Number, bool]): The first input is a number, or a bool,
or a tensor whose data type is number or bool.
y (Union[Tensor, numbers.Number, bool]): The second input is a number, or a bool when the first input
is a tensor, or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision among the two inputs.

Raises:
TypeError: If neither x nor y is one of the following: Tensor, number, bool.
TypeError: If neither x nor y is a Tensor.
ValueError: If the shape x and y cannot be broadcasted to each other.

Supported Platforms:
Ascend CPU GPU

Examples:
>>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
>>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> output = ops.truncate_mod(x, y)
>>> print(output)
[ 2  1 -1]
"""
return truncate_mod_(x, y)

[文档]def trunc(input_x):
r"""
Returns a new tensor with the truncated integer values of the elements of input.

Args:
input_x (Tensor): Input_x is a tensor.

Returns:
Tensor, the same shape and data type as the input.

Raises:
TypeError: If input_x is not a Tensor.

Supported Platforms:
CPU

Examples:
>>> input_x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]),mindspore.float32)
>>> output = ops.trunc(input_x)
>>> print(output)
[ 3. 0. 0. -3.]
"""
return trunc_(x)

def ldexp(x, other):
"""
Multiplies input by 2**:attr:other.

.. math::

out_{i} = input_{i} * ( 2_{i} ^{ other} )

Note:
Typically this function can create floating point numbers
by multiplying mantissas in input with powers of intger 2
from the exponents in :attr:’other’.

Args:
x (Tensor): The input tensor.
other (Tensor): A tensor of exponents, typically integers.

Outputs:
out (Tensor, optional) : the output tensor.

Raises:
TypeError: If x is not a Tensor.
TypeError: If other is not a Tensor.
ValueError: If the size of tensor x and other are different at non-singleton dimension, and not equal to 1.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import ops
>>> x = Tensor(np.array([1.]), mindspore.float32)
>>> other = Tensor(np.array([1, 2, 3, 4]), mindspore.int32)
>>> out = ops.ldexp(x, other)
>>> print(out)
[ 2.  4.  8. 16.]
"""

pow_ops = _get_cache_prim(P.Pow)()
mul_ops = _get_cache_prim(P.Mul)()

out = mul_ops(x, pow_ops(2.0, other))
return out

#####################################
# Comparison Operation Functions.
#####################################

[文档]def less(x, y):
r"""
Computes the boolean value of :math:x < y element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i}<y_{i} \\
& \text{False,   if } x_{i}>=y_{i}
\end{cases}

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,and the data type is bool.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> output = ops.less(x, y)
>>> print(output)
[False False True]
"""
return tensor_lt(x, y)

[文档]def le(x, y):
r"""
Computes the boolean value of :math:x <= y element-wise.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i}<=y_{i} \\
& \text{False,   if } x_{i}>y_{i}
\end{cases}

.. note::
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be both bool , and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_.
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> output = ops.le(x, y)
>>> print(output)
[ True False  True]
"""
return tensor_le(x, y)

[文档]def gt(x, y):
r"""
Compare the value of the input parameters :math:x,y element-wise, and the output result is a bool value.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i}>y_{i} \\
& \text{False,   if } x_{i}<=y_{i}
\end{cases}

Note:
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors, dtypes of them cannot be bool at the same time,
and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.
- If the input Tensor can be broadcast, the low dimension will be extended to the corresponding high dimension
in another input by copying the value of the dimension.

Args:
x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
a bool or a tensor whose data type is
number <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ or
bool_ <https://www.mindspore.cn/docs/en/r1.8/api_python/mindspore.html#mindspore.dtype>_ .
y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> output = ops.gt(x, y)
>>> print(output)
[False  True False]
"""
return tensor_gt(x, y)

[文档]def ge(x, y):
r"""
Computes the boolean value of :math:x >= y element-wise.

Note:
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors, dtypes of them cannot be bool at the same time,
and the shapes of them can be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.
- If the input Tensor can be broadcast, the low dimension will be extended to the corresponding high dimension
in another input by copying the value of the dimension.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i}>=y_{i} \\
& \text{False,   if } x_{i}<y_{i}
\end{cases}

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> output = ops.ge(x, y)
>>> print(output)
[True True False]
"""
return tensor_ge(x, y)

[文档]def equal(x, y):
r"""
Computes the equivalence between two tensors element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors, the shapes of them could be broadcast.
When the inputs are one tensor and one scalar, the scalar could only be a constant.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i} = y_{i} \\
& \text{False,   if } x_{i} \ne y_{i}
\end{cases}

Args:
x (Union[Tensor, Number]): The first input is a number or
a tensor whose data type is number.
y (Union[Tensor, Number]): The second input is a number
when the first input is a tensor or a tensor whose data type is number.
The data type is the same as the first input.

Returns:
Tensor, the shape is the same as the one after broadcasting,and the data type is bool.

Raises:
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> # case 1: The shape of two inputs are different
>>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> output = ops.equal(x, 2.0)
>>> print(output)
[False True False]
>>> # case 2: The shape of two inputs are the same
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 2, 4]), mindspore.int32)
>>> output = ops.equal(x, y)
>>> print(output)
[ True  True False]
"""
return equal_(x, y)

[文档]def ne(x, y):
r"""
Computes the non-equivalence of two tensors element-wise.

Note:
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors, the shapes of them could be broadcast.
- When the inputs are one tensor and one scalar, the scalar could only be a constant.

.. math::

out_{i} =\begin{cases}
& \text{True,    if } x_{i} \ne y_{i} \\
& \text{False,   if } x_{i} = y_{i}
\end{cases}

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,and the data type is bool.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.
TypeError: If neither x nor y is a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> output = ops.ne(x, 2.0)
>>> print(output)
[ True False  True]
>>>
>>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> y = Tensor(np.array([1, 2, 4]), mindspore.int32)
>>> output = ops.ne(x, y)
>>> print(output)
[False False  True]
"""
return not_equal(x, y)

[文档]def approximate_equal(x, y, tolerance=1e-5):
r"""
Returns True if abs(x-y) is smaller than tolerance element-wise, otherwise False.

.. math::

out_i = \begin{cases}
& \text{ if } \left | x_{i} - y_{i} \right | < \text{tolerance},\ \ True  \\
& \text{ if } \left | x_{i} - y_{i} \right | \ge \text{tolerance},\ \  False
\end{cases}

where tolerance indicates Acceptable maximum tolerance.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, the lower precision data type will be converted to
the relatively highest precision data type.

Args:
x (Tensor): A tensor. Must be one of the following types: float32, float16.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
y (Tensor): A tensor of the same type and shape as x.
tolerance (float): The maximum deviation that two elements can be considered equal. Default: 1e-05.

Returns:
Tensor, the shape is the same as the shape of x, and the data type is bool.

Raises:
TypeError: If tolerance is not a float.
RuntimeError: If the data type of x, y conversion of Parameter is given
but data type conversion of Parameter is not supported.

Supported Platforms:
Ascend

Examples:
>>> from mindspore.ops.function.math_func import approximate_equal
>>> tol = 2.
>>> x = Tensor(np.array([1, 2, 3]), mstype.float32)
>>> y = Tensor(np.array([2, 4, 6]), mstype.float32)
>>> output = approximate_equal(Tensor(x), Tensor(y), tol)
>>> print(output)
[ True  False  False]
"""
return P.ApproximateEqual(tolerance)(x, y)

[文档]def isfinite(x):
r"""
Determines which elements are finite for each position.

.. math::

out_i = \begin{cases}
& \text{ if } x_{i} = \text{Finite},\ \ True\  \\
& \text{ if } x_{i} \ne \text{Finite},\ \ False
\end{cases}

Args:
x (Tensor): The input tensor.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape of input, and the dtype is bool.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
>>> output = ops.isfinite(x)
>>> print(output)
[False  True False]
"""
return isfinite_(x)

[文档]def isnan(x):
r"""
Determines which elements are NaN for each position.

.. math::

out_i = \begin{cases}
& \ True,\ \text{ if } x_{i} = \text{Nan} \\
& \ False,\ \text{ if } x_{i} \ne  \text{Nan}
\end{cases}

where :math:Nan means not a number.

Args:
x (Tensor): The input tensor.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape of input, and the dtype is bool.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
GPU CPU

Examples:
>>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
>>> output = ops.isnan(x)
>>> print(output)
[ True False False]
"""
return isnan_(x)

[文档]def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
"""
Returns a new Tensor with boolean elements representing if each element of x1
is “close” to the corresponding element of x2. Closeness is defined as:

.. math::

∣x1−x2∣  ≤  atol + rtol × ∣x2∣

Args:
x1 (Tensor): First Tensor to compare, with data type belongs to float32, float16, int32.
x2 (Tensor): Second Tensor to compare, with data type belongs to float32, float16, int32.
rtol (float, optional): Relative tolerance. Default: 1e-05.
atol (float, optional): Absolute tolerance. Default: 1e-08.
equal_nan (bool, optional): If True, then two NaNs will be considered equal. Default: False.

Returns:
A bool Tensor, with the shape as broadcasted result of the input x1 and x2.

Raises:
TypeError: If either of x1 and x2 is not Tensor.
TypeError: If either of x1 and x2 is not float16, float32 or int32.
TypeError: If either of atol and rtol is not float.
TypeError: If equal_nan is not bool.
TypeError: If the dtype of x1 is not same as the x2.
ValueError: If x1 and x2 can not be broadcast.
ValueError: If either of atol and rtol is less than zero.

Supported Platforms:
CPU

Examples:
>>> input = Tensor(np.array([1.3, 2.1, 3.2, 4.1, 5.1]), mindspore.float16)
>>> other = Tensor(np.array([1.3, 3.3, 2.3, 3.1, 5.1]), mindspore.float16)
>>> output = ops.isclose(input, other)
>>> print(output)
[ True False False False  True]
"""
is_close = _get_cache_prim(P.IsClose)(rtol=rtol, atol=atol, equal_nan=equal_nan)
return is_close(x1, x2)

def isreal(x):
"""
Returns a new tensor with boolean elements representing whether each element of x is real-valued.
All real value types are considered real numbers.
A complex value is considered real when its imaginary part is 0.

Inputs:
x (Tensor): The input tensor.
:math:(N,*) where :math:* means, any number of additional dimensions.

Outputs:
Tensor, has the same shape of input, and the dtype is bool.

Raises:
TypeError: If x is not a Tensor.

Supported Platforms:
GPU CPU

Examples:
>>> from mindspore import ops
>>> x = Tensor([1, 1+1j, 2+0j], mstype.complex64)
>>> output = ops.isreal(x)
>>> print(output)
[ True False  True]
"""

if not isinstance(x, (Tensor, Tensor_)):
raise TypeError("the input x must be Tensor!")

# Note: Integral and Floating tensor values are always real
ones_op = _get_cache_prim(P.Ones)()
real_dtype = mstype.int_type + mstype.uint_type + mstype.float_type + (mstype.bool_,)
if x.dtype in real_dtype:
return ones_op(x.shape, mstype.bool_)

imag_op = _get_cache_prim(P.Imag)()
return imag_op(x) == 0

[文档]def same_type_shape(input_x, input_y):
"""
Checks whether the data type and shape of two tensors are the same.

Args:
input_x (Tensor): The shape of tensor is :math:(x_1, x_2, ..., x_R).
input_y (Tensor): The shape of tensor is :math:(x_1, x_2, ..., x_S).

Returns:
Tensor, the shape of tensor is :math:(x_1, x_2, ..., x_R),
if data type and shape of input_x and input_y are the same.

Raises:
TypeError: If the data types of input_x and input_y are not the same.
ValueError: If the shapes of input_x and input_y are not the same.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
>>> input_y = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
>>> output = ops.same_type_shape(input_x, input_y)
>>> print(output)
[[2. 2.]
[2. 2.]]
"""
return same_type_shape_(input_x, input_y)

[文档]def maximum(x, y):
"""
Computes the maximum of input tensors element-wise.

Note:
- Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
- The inputs must be two tensors or one tensor and one scalar.
- When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
- When the inputs are one tensor and one scalar,
the scalar could only be a constant.
- If one of the elements being compared is a NaN, then that element is returned.

.. math::
output_i = max(x_i, y_i)

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.
ValueError: If x and y are not the same shape.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> # case 1 : same data type
>>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
>>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
>>> output = ops.maximum(x, y)
>>> print(output)
[4. 5. 6.]
>>> # case 2 : different data type
>>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.int32)
>>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
>>> output = ops.maximum(x, y)
>>> print(output.dtype)
Float32
"""
return maximum_(x, y)

[文档]def minimum(x, y):
r"""
Computes the minimum of input tensors element-wise.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.
If one of the elements being compared is a NaN, then that element is returned.

.. math::
output_i = min(x_i, y_i)

Args:
x (Union[Tensor, Number, bool]): The first input is a number or
a bool or a tensor whose data type is number or bool.
y (Union[Tensor, Number, bool]): The second input is a number or
a bool when the first input is a tensor or a tensor whose data type is number or bool.

Returns:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.
ValueError: If x and y are not the same shape.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> # case 1 : same data type
>>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
>>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
>>> output = ops.minimum(x, y)
>>> print(output)
[1. 2. 3.]
>>> # case 2 : different data type
>>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.int32)
>>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
>>> output = ops.minimum(x, y)
>>> print(output.dtype)
Float32
"""
return minimum_(x, y)

def hypot(x1, x2):
"""
Computes hypotenuse of input tensors element-wise as legs of a right triangle.
The shape of two inputs should be broadcastable, and data type of them should be
one of: float32, float64

Args:
x1 (Tensor): The first input tensor.
x2 (Tensor): The second input tensor.

Returns:
Tensor, the shape is the same as the one after broadcasting, and the data type is one
with higher precision in the two inputs.

Raises:
TypeError: If data type x1 or x2 is not float32 or float64.
ValueError: If shape of two inputs are not broadcastable.

Supported Platforms:
Ascend CPU

Examples:
>>> x1 = Tensor(np.array([3., 5., 7.]))
>>> x2 = Tensor(np.array([4., 12., 24.]))
>>> y = ops.hypot(x1, x2)
>>> print(y)
[ 5. 13. 25.]
"""

hypot_ = Hypot()
return hypot_(x1, x2)

"""
Computes the logarithm of the sum of exponentiations of the inputs.

Calculates log(exp(x1) + exp(x2)). This function is useful in statistics, where the
computed probability of an event may be so small that it exceeds the range of a normal
floating point number. In this case, the logarithm of the calculated probability is stored.
This function allows to add probabilities stored in this way.

Args:
x1 (Tensor): Input Tensor.
x2 (Tensor): Input Tensor. If x1.shape != x2.shape, they must be broadcastable to
a common shape (which becomes the shape of the output).

Returns:
Tensor or scalar. This is a scalar if both x1 and x2 are scalars.

Raises:
TypeError: If x1, x2 is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x1 = Tensor(np.array([1, 2, 3]).astype(np.float16))
>>> x2 = Tensor(np.array(2).astype(np.float16))
>>> print(output)
[2.312 2.693 3.312]
"""

log_op = _get_cache_prim(P.Log)()
exp_op = _get_cache_prim(P.Exp)()

y = log_op(exp_op(x1) + exp_op(x2))
return y

"""
Computes the logarithm of the sum of exponentiations in base of 2 of the inputs.

Calculates log2(2**x1 + 2**x2). This function is useful in machine learning when the computed
probability of an event may be small beyond the range of normal floating point numbers.
In this case, the base-2 logarithm of the calculated probability can be used instead.
This function allows to add probabilities stored in this way.

Args:
x1 (Tensor): Input tensor.
x2 (Tensor): Input tensor. If x1.shape != x2.shape, they must be broadcastable to
a common shape (which becomes the shape of the output).

Returns:
Tensor or scalar. This is a scalar if both x1 and x2 are scalars.

Raises:
TypeError: If x1, x2 is not a Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x1 = Tensor(np.array([2, 4, 8]).astype(np.float16))
>>> x2 = Tensor(np.array([2]).astype(np.float16))
>>> print(output)
[3. 4.32 8.02]
"""

log_op = _get_cache_prim(P.Log)()
pow_op = _get_cache_prim(P.Pow)()

if not isinstance(x1, (Tensor, Tensor_)):
raise TypeError("The input x1 must be Tensor.")
if not isinstance(x2, (Tensor, Tensor_)):
raise TypeError("The input x2 must be Tensor.")

def outer(x1, x2):
"""
Return outer product of x1 and x2. If x1 is a vector of size n and x2 is a vector of size m,
then output must be a matrix of size n x m.

Note:

Args:
x1 (Tensor): 1-D input vector.
x2 (Tensor): 1-D input vector.

Outputs:
out (Tensor, optional) : optional output matrix.

Raises:
TypeError: If x1 is not a Tensor.
TypeError: If x2 is not a Tensor.
ValueError: Expected 1-D input x1, but got n-D.
ValueError: Expected 1-D input x2, but got n-D.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import ops
>>> x1 = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> x2 = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> out = ops.outer(x1, x2)
>>> print(out)
[[1 2 3]
[2 4 6]
[3 6 9]]
"""

if not isinstance(x1, (Tensor, Tensor_)):
raise TypeError("the input x1 must be Tensor!")
if not isinstance(x2, (Tensor, Tensor_)):
raise TypeError("the input x2 must be Tensor!")
if len(x1.shape) != 1:
raise ValueError("the input x1 must be a 1-D vector!")
if len(x2.shape) != 1:
raise ValueError("the input x2 must be a 1-D vector!")
x1 = x1.reshape(-1, 1)
mul_ops = _get_cache_prim(P.Mul)()
y = mul_ops(x1, x2)
return y

def mv(mat, vec):
"""
Multiplies matrix mat and vector vec.

If mat is a :math:(N, M) tensor, vec is a 1-D tensor of size :math:M, out will be 1-D of size :math:N.

Args:
mat (Tensor): Input matrix of the tensor. The shape of the tensor is :math:(N, M).
vec (Tensor): Input vector of the tensor. The shape of the tensor is :math:(M,).

Returns:
Tensor, the shape of the output tensor is :math:(N,).

Raises:
TypeError: If mat, vec is not a Tensor.
ValueError: If mat is not a 2-D Tensor.
If vec is not a 1-D Tensor.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> mat = Tensor(np.array([[3., 4.], [1., 6.], [1., 3.]]).astype(np.float32))
>>> vec = Tensor(np.array([1., 2.]).astype(np.float32))
>>> output = mv(mat, vec)
>>> print(output)
[11. 13. 7.]
"""

matmul_op = _get_cache_prim(P.MatMul)()
reshape_op = _get_cache_prim(P.Reshape)()

if not isinstance(mat, (Tensor, Tensor_)):
raise TypeError("The input mat must be Tensor.")
if not isinstance(vec, (Tensor, Tensor_)):
raise TypeError("The input vec must be Tensor.")
if len(mat.shape) != 2:
raise ValueError("The input mat must be 2-D Tensor.")
if len(vec.shape) != 1:
raise ValueError("The input vec must be 1-D Tensor.")

length_vec = get_x_shape(vec.shape)
vec = reshape_op(vec, (length_vec[0], 1))

out = matmul_op(mat, vec)
out = out.T
out = out[0]
return out

def lcm(x1, x2):
"""
Computes least common multiplier of input tensors element-wise.
The shape of two inputs should be broadcastable, and data type of them should be
one of: int32, int64

Inputs:
- **x1** (Tensor) - The first input tensor.
- **x2** (Tensor) - The second input tensor.

Outputs:
Tensor, the shape is the same as the one after broadcasting, and the data type is one
with higher digits in the two inputs.

Raises:
TypeError: If data type x1 or x2 is not int32 or int64.
ValueError: If shape of two inputs are not broadcastable.

Supported Platforms:
Ascend CPU

Examples:
>>> x1 = Tensor(np.array([7, 8, 9]))
>>> x2 = Tensor(np.array([14, 6, 12]))
>>> y = ops.lcm(x1, x2)
>>> print(y)
[14 24 36]
"""

lcm_ = _get_cache_prim(Lcm)()
return lcm_(x1, x2)

def cdist(x, y, p=2.0):
"""
Computes batched the p-norm distance between each pair of the two collections of row vectors.

Args:
x (Tensor): Input tensor of shape :math:(B, P, M).
Letter :math:B represents 0 or positive int number.
When :math:B is equal to 0, it means this dimension can be ignored,
i.e. shape of the tensor is :math:(P, M).
y (Tensor): Input tensor of shape :math:(B, R, M).
p (float): P value for the p-norm distance to calculate between each vector pair, P ∈ [0,∞]. Default: 2.0.

Returns:
Tensor, has the same dtype as x, which shape is :math:(B, P, R).

Raises:
TypeError: If x or y is not a Tensor.
TypeError: If dtype of x or y is neither float16 nor float32.
TypeError: If p is not a float.
ValueError: If p is a negative float.
ValueError: If dimension of x is not the same as y.
ValueError: If dimension of x or y is neither 2 nor 3.

Supported Platforms:
Ascend CPU

Examples:
>>> from mindspore.ops import functional as F
>>> x = Tensor(np.array([[[1.0, 1.0], [2.0, 2.0]]]).astype(np.float32))
>>> y = Tensor(np.array([[[3.0, 3.0], [3.0, 3.0]]]).astype(np.float32))
>>> output = F.cdist(x, y, 2.0)
>>> print(output)
[[[2.8284273 2.8284273]
[1.4142137 1.4142137]]]
"""
cdist_ = _get_cache_prim(P.Cdist)(p)
return cdist_(x, y)

def gcd(x1, x2):
"""
Computes greatest common divisor of input tensors element-wise.
The shape of two inputs should be broadcastable, and data type of them should be
one of: int32, int64

Inputs:
- **x1** (Tensor) - The first input tensor.
- **x2** (Tensor) - The second input tensor.

Outputs:
Tensor, the shape is the same as the one after broadcasting, and the data type is one
with higher digits in the two inputs.

Raises:
TypeError: If data type x1 or x2 is not int32 or int64.
ValueError: If shape of two inputs are not broadcastable.

Supported Platforms:
Ascend CPU

Examples:
>>> x1 = Tensor(np.array([7, 8, 9]))
>>> x2 = Tensor(np.array([14, 6, 12]))
>>> y = ops.gcd(x1, x2)
>>> print(y)
[7 2 3]
"""

gcd_ = _get_cache_prim(Gcd)()
return gcd_(x1, x2)

[文档]def lerp(start, end, weight):
"""
Does a linear interpolation of two tensors start and end based on a float or tensor weight.

If weight is a tensor, the shapes of three inputs need to be broadcast;
If weight is a float, the shapes of start and end need to be broadcast.

.. math::

output_{i} = start_{i} + weight_{i} * (end_{i} - start_{i})

Args:
start (Tensor): The tensor with the starting points. Data type must be float16 or float32.
end (Tensor): The tensor with the ending points. Data type must be float16 or float32.
weight (Union[float, Tensor]): The weight for the interpolation formula. Must be a float
or a scalar tensor with float16 or float32 data type.

Returns:
Tensor, has the same type and shape as input start.

Raises:
TypeError: If start or end is not a tensor.
TypeError: If weight is neither scalar(float) nor tensor.
TypeError: If dtype of start or end is neither float16 nor float32.
TypeError: If dtype of weight is neither float16 nor float32 when it is a tensor.
TypeError: If start and end have different data types.
TypeError: If start, end and weight have different data types when weight is a tensor.
ValueError: If end could not be broadcast to a tensor with shape of start.
ValueError: If weight could not be broadcast to tensors with shapes of start and end when it is a tensor.

Supported Platforms:
Ascend CPU

Examples:
>>> start = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
>>> end = Tensor(np.array([10., 10., 10., 10.]), mindspore.float32)
>>> output = ops.lerp(start, end, 0.5)
>>> print(output)
[5.5 6. 6.5 7. ]
"""
return lerp_(start, end, weight)

[文档]def bernoulli(x, p=0.5, seed=-1):
r"""
Randomly set the elements of output to 0 or 1 with the probability of P which follows the Bernoulli distribution.

.. math::
out_{i} \sim Bernoulli(p_{i})

Args:
x (Tensor): Tensor of shape :math:(N,*) where :math:* means, any number of additional dimensions. Data
type must be int8, uint8, int16, int32, int64, bool, float32 or float64.
p (Union[Tensor, float], optional): The shape of p need to be broadcast. Data type must be float32 or float64.
The elements of p represent the probability of setting 1 for the
corresponding broadcast position of the current Tensor. The value of p
must be in the range [0, 1]. Default: 0.5.
seed (int, optional): The seed value for random generating. The value of seed must be -1 or a positive
integer. Default: -1, which means using the current timestamp.

Returns:
output (Tensor), with the same shape and type as x.

Raises:
TypeError: If dtype of x is not one of: int8, uint8, int16, int32, int64, bool, float32, float64.
TypeError: If dtype of p is not one of: float32, float64.
TypeError: If dtype of seed is not int.
ValueError: If p is not in range [0, 1].
ValueError: If seed is less than 0 and not -1.

Supported Platforms:
GPU

Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor
>>> import mindspore.ops as ops
>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int8)
>>> output = ops.bernoulli(input_x, p=1.0)
>>> print(output)
[1 1 1]
>>> input_p = Tensor(np.array([0.0, 1.0, 1.0]), mindspore.float32)
>>> output = ops.bernoulli(input_x, input_p)
>>> print(output)
[0 1 1]
"""
bernoulli_ = _get_cache_prim(Bernoulli)(seed)
return bernoulli_(x, p)

[文档]def bessel_i1(x):
r"""
Computes the Bessel i1 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([-1, -0.5, 0.5, 1]), mindspore.float32)
>>> output = ops.bessel_i1(x)
>>> print(output)
[-0.5651591  -0.25789431  0.25789431  0.5651591]
"""
return bessel_i1_(x)

[文档]def bessel_i1e(x):
r"""
Computes the Bessel i1e function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([-1, -0.5, 0.5, 1]), mindspore.float32)
>>> output = ops.bessel_i1e(x)
>>> print(output)
[-0.20791042  -0.15642083  0.15642083  0.20791042]
"""
return bessel_i1e_(x)

[文档]def bessel_k1(x):
r"""
Computes the Bessel k1 function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_k1(x)
>>> print(output)
[1.65644112  0.60190723  0.13986588  0.0124835]
"""
return bessel_k1_(x)

[文档]def bessel_k1e(x):
r"""
Computes the Bessel k1e function of x element-wise.

Args:
x (Tensor): The input tensor. The data type must be float16, float32 or float64.
:math:(N,*) where :math:* means, any number of additional dimensions.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16, float32 or float64.

Supported Platforms:
CPU

Examples:
>>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
>>> output = ops.bessel_k1e(x)
>>> print(output)
[2.73100971  1.63615349  1.03347685  0.68157595]
"""
return bessel_k1e_(x)

@constexpr
def _check_input_dtype(param_name, input_dtype, allow_dtypes, cls_name):
validator.check_type_name(param_name, input_dtype, allow_dtypes, cls_name)

"""
Calculates a new tensor with each of the elements of x converted from angles in degrees to radians.

Args:
x (Tensor[Number]): The input tensor. It must be a positive-definite matrix.
With float16, float32 or float64 data type.

Returns:
Tensor, has the same dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x isn't float16, float32 or float64.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([[90.0, -90.0], [180.0, -180.0], [270.0, -270.0]]).astype(np.float32))
>>> output = op(x)
>>> print(output)
[[ 1.5707964 -1.5707964]
[ 3.1415927 -3.1415927]
[ 4.712389  -4.712389 ]]
"""
if not isinstance(x, (Tensor, Tensor_)):
raise TypeError("The input x must be tensor")
dtype_op = _get_cache_prim(P.DType)()
x_dtype = dtype_op(x)
_check_input_dtype("x", x_dtype, [mstype.float16, mstype.float32, mstype.float64], "")
if x_dtype == mstype.float16:
out = x * (Tensor(math.pi / 180.0).astype(mstype.float16))
else:
out = x * math.pi / 180.0
return out

"""
Returns a new tensor with each of the elements of x converted from angles in radians to degrees.

Args:
x (Tensor): The input tensor.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x isn't float16, float32 or float64.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> import mindspore
>>> from mindspore import Tensor
>>> import mindspore.ops as ops
>>> x = Tensor([[6.283, -3.142],[1.570, -6.283],[3.142, -1.570]], mindspore.float32)
>>> print(output)
[[ 359.98935 -180.02333]
[  89.95438 -359.98935]
[ 180.02333  -89.95438]]

"""
if not isinstance(x, (Tensor, Tensor_)):
raise TypeError("The input x must be tensor")
dtype_op = _get_cache_prim(P.DType)()
x_dtype = dtype_op(x)
_check_input_dtype("x", x_dtype, [mstype.float16, mstype.float32, mstype.float64], "")
if x_dtype == mstype.float16:
out = x * (Tensor(180.0 / math.pi).astype(mstype.float16))
else:
out = x * 180.0 / math.pi
return out

#####################################
# Reduction Operation Functions.
#####################################

@constexpr
def _create_cummin_perm(axis, x_shape):
"""Insure axis is in [-len(x_shape),len(s_shape)-1]"""
len_axis = len(x_shape)
if not isinstance(axis, int):
raise TypeError(f"The date type of 'axis' must be Int, but got {axis}.")
if axis < -len_axis or axis > len_axis:
raise ValueError(f"The value of axis must be in [{-len_axis}, {len_axis}], but got {axis}.")
prem = [i for i in range(len_axis)]
if axis < 0:
axis = axis + len_axis
prem[0], prem[axis] = axis, 0
prem = tuple(prem)
return prem

[文档]def cummin(x, axis):
r"""
Returns a tuple (values,indices) where 'values' is the cumulative minimum value of input Tensor x
along the dimension axis, and indices is the index location of each minimum value.

.. math::
\begin{array}{ll} \\
y{i} = min(x{1}, x{2}, ... , x{i})
\end{array}

Args:
x (Tensor): The input Tensor, rank of x > 0.
axis (int): The dimension to do the operation over. The value of axis must be in the range
[-x.ndim, x.ndim - 1].

Returns:
tuple [Tensor], tuple of 2 Tensors, containing the cumulative minimum of elements and the index,
The shape of each output tensor is the same as input x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not an int.
ValueError: If axis is out the range of [-x.ndim, x.ndim - 1].

Supported Platforms:
Ascend GPU CPU

Examples:
>>> from mindspore import Tensor, ops
>>> import mindspore
>>> a = Tensor([-0.2284, -0.6628,  0.0975,  0.2680, -1.3298, -0.4220], mindspore.float32)
>>> output = ops.cummin(a, axis=0)
>>> print(output[0])
[-0.2284 -0.6628 -0.6628 -0.6628 -1.3298 -1.3298]
>>> print(output[1])
[0 1 1 1 4 4]
"""
cummin_op = _get_cache_prim(Cummin)(axis=0)
if axis == 0:
out1, out2 = cummin_op(x)
else:
transpose = _get_cache_prim(P.Transpose)()
_shape_op = _get_cache_prim(P.Shape)()
x_shape = _shape_op(x)
prem = _create_cummin_perm(axis, x_shape)
x = transpose(x, prem)
out1, out2 = cummin_op(x)
out1 = transpose(out1, prem)
out2 = transpose(out2, prem)
return [out1, out2]

[文档]def cummax(x, axis):
r"""
Returns a tuple (values,indices) where 'values' is the cumulative maximum value of input Tensor x
along the dimension axis, and indices is the index location of each maximum value.

.. math::
\begin{array}{ll} \\
y{i} = max(x{1}, x{2}, ... , x{i})
\end{array}

Args:
x (Tensor): The input Tensor, rank of x > 0.
axis (int): The dimension to do the operation over. The value of axis must be in the range
[-x.ndim, x.ndim - 1].

Returns:
tuple [Tensor], tuple of 2 Tensors, containing the cumulative maximum of elements and the index,
The shape of each output tensor is the same as input x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not an int.
ValueError: If axis is out the range of [-x.ndim, x.ndim - 1].

Supported Platforms:
GPU CPU

Examples:
>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor
>>> import mindspore.ops as ops
>>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
>>> output = ops.cummax(x, axis=0)
>>> print(output[0])
[[ 3.  4.  6. 10.]
[ 3.  6.  7. 10.]
[ 4.  6.  8. 10.]
[ 4.  6.  8. 10.]]
>>> print(output[1])
[[0 0 0 0]
[0 1 1 0]
[2 1 2 0]
[2 1 2 0]]
"""
_cummax = _get_cache_prim(ops.Cummax)(axis=axis)
return _cummax(x)

[文档]def sparse_segment_mean(x, indices, segment_ids):
r"""
Computes a Tensor such that :math:output_i = \frac{\sum_j x_{indices[j]}}{N} where mean is over :math:j such
that :math:segment\_ids[j] == i and :math:N is the total number of values summed. If the mean is empty for
a given segment ID :math:i, :math:output[i] = 0.

Note:
- On CPU, values in segment_ids are always validated to be sorted, and an error is thrown for indices that
are not increasing. Moreover, values in indices are validated to be bounded, and an error is thrown when
indices are out of range[0, x.shape[0]).
- On GPU, this does not throw an error for unsorted segment_ids and out-of-bound indices. Out-of-order
segment_ids result in safe but unspecified behavior, while out-of-range indices will be ignored.

Args:
x (Tensor): A Tensor, and its rank must be greater than or equal to 1.
indices (Tensor): A 1-D Tensor, with int32 or int64 data type.
segment_ids (Tensor): A 1-D Tensor, must have the same dtype as indices.
Values should be sorted and can be repeated.

Returns:
Tensor, whose dtype and rank is the same as x. The first dimension is equal to the value of the last element
of segment_ids plus one, and the other dimensions are the same as those of x.

Raises:
TypeError: If x, indices or segment_ids is not a Tensor.
TypeError: If the dtype of x is not one of the following dtype: float16, float32, float64.
TypeError: If the dtype of indices and segment_ids are not one of the following dtype: int32, int64.
TypeError: If the dtype of indices and segment_ids are not the same.
ValueError: If the shape of x, 'indices' or segment_ids don't meet the parameter description.
ValueError: If the size of 'indices' and segment_ids are not the same.

Supported Platforms:
GPU CPU

Examples:
>>> x = Tensor([[0, 1, 2], [1, 2, 3], [3, 6, 7]], dtype=mindspore.float32)
>>> indices = Tensor([0, 1, 2], dtype=mindspore.int32)
>>> segment_ids = Tensor([1,2,2], dtype=mindspore.int32)
>>> out = ops.sparse_segment_mean(x, indices, segment_ids)
>>> print(out)
[[0. 0. 0.]
[0. 1. 2.]
[2. 4. 5.]]
"""
return sparse_segment_mean_(x, indices, segment_ids)

[文档]def logsumexp(x, axis, keep_dims=False):
r"""
Reduces a dimension of a tensor by calculating exponential for all elements in the dimension,
then calculate logarithm of the sum.

.. math::

logsumexp(x) = \log(\sum(e^(x-x_{max}))) + x_{max}

Args:
x (Tensor): The input tensor. With float16 or float32 data type.
axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed.
keep_dims (bool): If True, keep these reduced dimensions and the length is 1.
If False, don't keep these dimensions.
Default : False.

Returns:
Tensor, has the same dtype as the x.

- If axis is (), and keep_dims is False,
the output is a 0-D tensor representing the sum of all elements in the input tensor.
- If axis is int, set as 2, and keep_dims is False,
the shape of output is :math:(x_1, x_3, ..., x_R).
- If axis is tuple(int), set as (2, 3), and keep_dims is False,
the shape of output is :math:(x_1, x_4, ..., x_R).

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = ops.logsumexp(x, 1, keep_dims=True)
>>> print(output.shape)
(3, 1, 5, 6)
"""
_exp = _get_cache_prim(P.Exp)()
_reduce_sum = _get_cache_prim(P.ReduceSum)(keep_dims)
_log = _get_cache_prim(P.Log)()

x_max = x.max()
x_exp = _exp(x - x_max)
x_sumexp = _reduce_sum(x_exp, axis)
x_logsumexp = _log(x_sumexp)
return x_logsumexp + x_max

[文档]def amin(x, axis=(), keep_dims=False):
r"""
Reduces a dimension of a tensor by the minimum value in the dimension, by default. And also can
reduce a dimension of x along the axis. Determine whether the dimensions of the output and input are the same by
controlling keep_dims.

Args:
x (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Assume the rank of x is r, and the value range is [-r,r).
keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
If false, don't keep these dimensions. Default: False.

Returns:
Tensor, has the same data type as input tensor.

- If axis is () and keep_dims is False, output a 0-dimensional Tensor representing the minimum value of
all elements in the input Tensor.
- If axis is int, takes the value 1, and keep_dims is False, the shape of the output is
:math:(x_0, x_2, ..., x_R) .
- If axis is tuple(int) or list(int), the value is (1, 2), and keep_dims is False, the shape of the output
Tensor is: math:(x_0, x_3, ... , x_R) .

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not one of the following: int, tuple or list.
TypeError: If keep_dims is not a bool.
ValueError: If axis is out of range.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = ops.amin(x, 1, keep_dims=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by the minimum value of all elements in the dimension.
>>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
>>> output = ops.amin(x)
>>> print(output)
1.0
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along axis 0.
>>> output = ops.amin(x, 0, True)
>>> print(output)
[[[1. 1. 1. 1. 1. 1.]
[2. 2. 2. 2. 2. 2.]
[3. 3. 3. 3. 3. 3.]]]
>>> # case 3: Reduces a dimension along axis 1.
>>> output = ops.amin(x, 1, True)
>>> print(output)
[[[1. 1. 1. 1. 1. 1.]]
[[4. 4. 4. 4. 4. 4.]]
[[7. 7. 7. 7. 7. 7.]]]
>>> # case 4: Reduces a dimension along axis 2.
>>> output = ops.amin(x, 2, True)
>>> print(output)
[[[1.]
[2.]
[3.]]
[[4.]
[5.]
[6.]]
[[7.]
[8.]
[9.]]]
"""
return _get_cache_prim(P.ReduceMin)(keep_dims)(x, axis)

[文档]def amax(x, axis=(), keep_dims=False):
r"""
Reduces a dimension of a tensor by the maximum value in this dimension, by default. And also can
reduce a dimension of x along the axis. Determine whether the dimensions of the output and input are the same by
controlling keep_dims.

Args:
x (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Assume the rank of x is r, and the value range is [-r,r).
keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
If false, don't keep these dimensions. Default: False.

Returns:
Tensor, has the same data type as input tensor.

- If axis is () and keep_dims is False, output a 0-dimensional Tensor representing the maximum value
of all elements in the input Tensor.
- If axis is int, takes the value 1, and keep_dims is False, the shape of the output is
:math:(x_0, x_2, ..., x_R) .
- If axis is tuple(int) or list(int), the value is (1, 2), and keep_dims is False, the shape of the
output Tensor is: math:(x_0, x_3, ... , x_R) .

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not one of the following: int, tuple or list.
TypeError: If keep_dims is not a bool.
ValueError: If axis is out of range.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = ops.amax(x, 1, keep_dims=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by the maximum value of all elements in the dimension.
>>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
>>> output = ops.amax(x)
>>> print(output)
9.0
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along axis 0.
>>> output = ops.amax(x, 0, True)
>>> print(output)
[[[7. 7. 7. 7. 7. 7.]
[8. 8. 8. 8. 8. 8.]
[9. 9. 9. 9. 9. 9.]]]
>>> # case 3: Reduces a dimension along axis 1.
>>> output = ops.amax(x, 1, True)
>>> print(output)
[[[3. 3. 3. 3. 3. 3.]]
[[6. 6. 6. 6. 6. 6.]]
[[9. 9. 9. 9. 9. 9.]]]
>>> # case 4: Reduces a dimension along axis 2.
>>> output = ops.amax(x, 2, True)
>>> print(output)
[[[1.]
[2.]
[3.]]
[[4.]
[5.]
[6.]]
[[7.]
[8.]
[9.]]]
"""
return _get_cache_prim(P.ReduceMax)(keep_dims)(x, axis)

[文档]def mean(x, axis=(), keep_dims=False):
r"""
Reduces a dimension of a tensor by averaging all elements in the dimension, by default. And also can reduce
a dimension of x along the axis. Determine whether the dimensions of the output and input are the same by
controlling keep_dims.

Args:
x (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Assume the rank of x is r, and the value range is [-r,r).
keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
If false, don't keep these dimensions. Default: False.

Returns:
Tensor, has the same data type as input tensor.

- If axis is () and keep_dims is False, output a 0-dimensional Tensor representing the average of all
elements in the input Tensor.
- If axis is int, takes the value 1, and keep_dims is False, the shape of the output is
:math:(x_0, x_2, ..., x_R) .
- If axis is tuple(int) or list(int), the value is (1, 2), and keep_dims is False, the shape of the
output Tensor is: math:(x_0, x_3, ... , x_R) .

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not one of the following: int, tuple or list.
TypeError: If keep_dims is not a bool.
ValueError: If axis is out of range.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = ops.mean(x, 1, keep_dims=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by averaging all elements in the dimension.
>>> x = Tensor(np.array([[[2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2]],
... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
... mindspore.float32)
>>> output = ops.mean(x)
>>> print(output)
5.0
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along the axis 0
>>> output = ops.mean(x, 0, True)
>>> print(output)
[[[4. 4. 4. 4. 4. 4.]
[5. 5. 5. 5. 5. 5.]
[6. 6. 6. 6. 6. 6.]]]
>>> # case 3: Reduces a dimension along the axis 1
>>> output = ops.mean(x, 1, True)
>>> print(output)
[[[2. 2. 2. 2. 2. 2.]]
[[5. 5. 5. 5. 5. 5.]]
[[8. 8. 8. 8. 8. 8.]]]
>>> # case 4: Reduces a dimension along the axis 2
>>> output = ops.mean(x, 2, True)
>>> print(output)
[[[ 2.]
[ 2.]
[ 2.]]
[[ 4.]
[ 5.]
[ 6.]]
[[ 6.]
[ 8.]
[10.]]]
"""

return _get_cache_prim(P.ReduceMean)(keep_dims)(x, axis)

[文档]def prod(x, axis=(), keep_dims=False):
r"""
Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
reduce a dimension of x along the axis. Determine whether the dimensions of the output and input are the same by
controlling keep_dims.

Args:
x (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
:math:(N,*) where :math:* means, any number of additional dimensions, its rank should be less than 8.
axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Assume the rank of x is r, and the value range is [-r,r).
keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
If false, don't keep these dimensions. Default: False.

Returns:
Tensor, has the same data type as input tensor.

- If axis is () and keep_dims is False, output a 0-dimensional Tensor representing the product of all
elements in the input Tensor.
- If axis is int, takes the value 1, and keep_dims is False, the shape of the output is
:math:(x_0, x_2, ..., x_R).
- If axis is tuple(int) or list(int), the value is (1, 2), and keep_dims is False, the shape of
the output Tensor is: math:(x_0, x_3, ... , x_R).

Raises:
TypeError: If x is not a Tensor.
TypeError: If axis is not one of the following: int, tuple or list.
TypeError: If keep_dims is not a bool.
ValueError: If axis is out of range.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
>>> output = ops.prod(x, 1, keep_dims=True)
>>> result = output.shape
>>> print(result)
(3, 1, 5, 6)
>>> # case 1: Reduces a dimension by multiplying all elements in the dimension.
>>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
>>> output = ops.prod(x)
>>> print(output)
2.2833798e+33
>>> print(output.shape)
()
>>> # case 2: Reduces a dimension along axis 0.
>>> output = ops.prod(x, 0, True)
>>> print(output)
[[[ 28.  28.  28.  28.  28.  28.]
[ 80.  80.  80.  80.  80.  80.]
[162. 162. 162. 162. 162. 162.]]]
>>> # case 3: Reduces a dimension along axis 1.
>>> output = ops.prod(x, 1, True)
>>> print(output)
[[[  6.   6.   6.   6.   6.   6.]]
[[120. 120. 120. 120. 120. 120.]]
[[504. 504. 504. 504. 504. 504.]]]
>>> # case 4: Reduces a dimension along axis 2.
>>> output = ops.prod(x, 2, True)
>>> print(output)
[[[1.00000e+00]
[6.40000e+01]
[7.29000e+02]]
[[4.09600e+03]
[1.56250e+04]
[4.66560e+04]]
[[1.17649e+05]
[2.62144e+05]
[5.31441e+05]]]
"""
return _get_cache_prim(P.ReduceProd)(keep_dims)(x, axis)

[文档]def norm(input_x, axis, p=2, keep_dims=False, epsilon=1e-12):
r"""
Returns the matrix norm or vector norm of a given tensor.

.. math::
output = sum(abs(input)**p)**(1/p)

Args:
input_x (Tensor): Input tensor. The dtype must be float32 or float16.
axis (Union[int,list,tuple]): Specifies which dimension or dimensions of input to calculate the norm across.
p (int): The order of norm. Default: 2. p is greater than or equal to 0.
keep_dims (bool): Whether the output tensors have dim retained or not. Default: False.
epsilon (float): A value added to the denominator for numerical stability. Default: 1e-12.

Returns:
Tensor, has the same dtype as input, which shape depends on the args axis. For example, if the size of input
is (2, 3, 4), axis is [0, 1], Outputs' shape will be (4,).

Raises:
TypeError: If input is not a Tensor.
TypeError: If dtype of input is not one of: float16, float32.
TypeError: If p is not an int.
TypeError: If axis is not an int, a tuple or a list.
TypeError: If axis is a tuple or a list, but the element of axis is not an int.
TypeError: If keep_dims is not a bool.
TypeError: If epsilon is not a float.
ValueError: If the element of axis is out of the range [-len(input.shape), len(input.shape)).
ValueError: If the length of shape of axis is bigger than the length of shape of input.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input_x = Tensor(np.array([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]).astype(np.float32))
>>> output = ops.norm(input_x, [0, 1], p=2)
>>> print(output)
[ 9.165152 10.954452]
"""
lp_norm_inner = _get_cache_prim(P.LpNorm)(axis, p, keep_dims, epsilon)
return lp_norm_inner(input_x)

[文档]def renorm(input_x, p, dim, maxnorm):
"""
Renormalizes the sub-tensors along dimension dim, and each sub-tensor's p-norm should not exceed the
'maxnorm'. The values of current sub-tensor don't need change if the p-norm of the sub-tensor is less than
maxnorm. Otherwise the sub-tensor needs to be modified to the original value of the corresponding position
divided by the p-norm of the substensor and then multiplied by maxnorm.

Args:
input_x: A Tensor, types: float32 or float16.
p (float): Power of norm calculation.
dim (int): The dimension that expected to get the slice-tensor.
maxnorm (float): Max norm.

Returns:
Tensor, has the same dtype and shape as input_x.

Raises:
TypeError: If dtype of p is not int.
TypeError: If dtype of dim is not int.
TypeError: If dtype of maxnorm is not float32.
ValueError: If the value of p less than 1.

Supported Platforms:
Ascend CPU GPU

Examples:
>>> x = Tensor(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), mindspore.float32)
>>> y = ops.renorm(x, p=1, dim=0, maxnorm=5.)
>>> print(y)
[[1.       1.        1.        ]
[1.6666666 1.6666666 1.6666666 ]
[1.6666667 1.6666667 1.6666667 ]]
"""
renorm_ = _get_cache_prim(Renorm)(p, dim, maxnorm)
return renorm_(input_x)

@constexpr
def _check_attr_dtype(param_name, input_dtype, allow_dtypes, cls_name):
validator.check_value_type(param_name, input_dtype, allow_dtypes, cls_name)

@constexpr
def _check_positive_float(arg_value, arg_name, cls_name):
validator.check_positive_float(arg_value, arg_name, cls_name)

@constexpr
def _check_int_range(arg_value, lower_limit, upper_limit, arg_name=None, prim_name=None):
validator.check_int_range(arg_value, lower_limit, upper_limit, Rel.INC_LEFT, arg_name, prim_name)

[文档]def gumbel_softmax(logits, tau=1, hard=False, dim=-1):
r"""
Returns the samples from the Gumbel-Softmax distribution and optionally discretizes. If hard = True, the returned
samples will be one-hot, otherwise it will be probability distributions that sum to 1 across dim.

Args:
logits (Tensor): Unnormalized log probabilities. The data type must be float16 or float32.
tau (float): The scalar temperature, which is a positive number. Default: 1.0.
hard (bool): if True, the returned samples will be discretized as one-hot vectors, but will be differentiated
as if it is the soft sample in autograd. Default: False.
dim (int): Dim for softmax to compute. Default: -1.

Returns:
Tensor, has the same dtype and shape as logits.

Raises:
TypeError: If logits is not a Tensor.
TypeError: If dtype of logits is not one of: float16, float32.
TypeError: If tau is not an float.
TypeError: If hard is not a bool.
TypeError: If dim is not a int.
ValueError: If If tau is not positive.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
>>> output = ops.gumbel_softmax(input_x, 1.0, True, -1)
>>> print(output.shape)
(2, 3)
"""
if not isinstance(logits, (Tensor, Tensor_)):
raise TypeError("The input logits must be tensor")
if logits.shape == ():
raise ValueError("For gumbel_softmax, the 0-D input is not supported.")
dtype_op = _get_cache_prim(P.DType)()
logits_dtype = dtype_op(logits)
_check_input_dtype("logits", logits_dtype, [mstype.float16, mstype.float32], "gumbel_softmax")
_check_attr_dtype("tau", tau, [float], "gumbel_softmax")
_check_attr_dtype("hard", hard, [bool], "gumbel_softmax")
_check_attr_dtype("dim", dim, [int], "gumbel_softmax")
_check_positive_float(tau, "tau", "gumbel_softmax")
if hard:
_check_int_range(dim, -1, len(logits.shape), 'dim', "gumbel_softmax")
else:
_check_int_range(dim, -len(logits.shape), len(logits.shape), 'dim', "gumbel_softmax")

shape_op = _get_cache_prim(P.Shape)()
cast_op = _get_cache_prim(P.Cast)()
log_op = _get_cache_prim(P.Log)()
const_op = _get_cache_prim(P.ScalarToArray)()
softmax_op = _get_cache_prim(P.Softmax)(dim)
onehot_op = _get_cache_prim(P.OneHot)(dim)

sample_shape = shape_op(logits)
uniform = C.uniform(sample_shape, const_op(0.0), const_op(1.0))
uniform = cast_op(uniform, logits_dtype)
gumbel = neg_tensor(log_op(neg_tensor(log_op(uniform))))
gumbel = (logits + gumbel) / tau
y_soft = softmax_op(gumbel)
if hard:
index = y_soft.argmax(axis=dim)
y_hard = onehot_op(index, sample_shape[dim], Tensor(1, logits_dtype), Tensor(0, logits_dtype))
ret = y_hard - ops.stop_gradient(y_soft) + y_soft
else:
ret = y_soft
return ret

def stft(x, n_fft, hop_length=None, win_length=None, window=None, center=True,
r"""
STFTs can be used as a way of quantifying the change
of a nonstationary signal’s frequency and phase content over time.

Args:
x (Tensor): Time sequence of stft, must be either a 1-D time tensor or a 2-D tensor.
n_fft (int): The size of Fourier transform.
hop_length (int, optional): The distance between neighboring sliding window
frames. Default: None (treated as equal to floor(n_fft / 4)).
win_length (int, optional): the size of window frame and STFT filter.
Default: None  (treated as equal to :attr:n_fft).
window (Tensor, optional): the optional window function.
Default: None (treated as window of all :math:1 s).
center (bool, optional): whether to pad :attr:input on both sides.
Default: True.
:attr:center is True. Default: "REFLECT".
normalized (bool, optional): controls whether to return the normalized STFT results
Default: False.
onesided (bool, optional): controls whether to return half of results to
avoid redundancy for real inputs.
Default: True for real :attr:input and :attr:window, False otherwise.
return_complex (bool, optional): whether to return a complex tensor, or
a real tensor with an extra last dimension for the real and
imaginary components.
Default: True for complex :attr:input or :attr:window, False otherwise.

Returns:
Tensor.

- **output** (Tensor) - A tensor containing the STFT result with shape described above.

Raises:
TypeError: If the x is not a tensor.
ValueError: If x arguments have values not specified above.

Examples:
>>> x = Tensor(np.random.rand(2,7192), mindspore.float32)
>>> output = ops.stft(n_fft=64, x=x)
>>> print(output.shape)
(2, 33, 450, 2)
"""
if hop_length is None:
hop_length = int(np.floor(n_fft / 4))
if win_length is None:
win_length = int(np.floor(n_fft))
if window is None:
window = P.Ones()((win_length,), mstype.float32)

def _is_complex(x):
dtype = P.DType()
return dtype(x) in [mstype.complex64, mstype.complex128]

if onesided is None:
onesided = (not _is_complex(x)) and (not _is_complex(window))
if return_complex is None:
return_complex = _is_complex(x) or _is_complex(window)
if center:
_check_input_dtype("center", center, [bool], "")
signal_dim = len(x.shape)
if signal_dim == 1:
elif signal_dim == 2:
else:
raise ValueError(
f"Expected a 1-D tensor or a 2-D tensor, but got {signal_dim}")
stft_ = STFT(n_fft, hop_length, win_length,
normalized, onesided, return_complex)
return stft_(x, window)

def _check_same_type(dtype1, dtype2):
return dtype1 == dtype2

@constexpr
def _max(*args):
"""Returns the maximum value."""
return max(*args)

@constexpr
def _min(*args):
"""Returns the minimum value."""
return min(*args)

@constexpr
def _infer_shape_rem(shape1, shape2, ndim1, ndim2, transpose_b):
"""Infers the shape of the last two dimensions after performing matmul."""
shape_rem = []
if ndim1 >= 2:
shape_rem.append(shape1[-2])
if transpose_b:
if ndim2 >= 2:
shape_rem.append(shape2[-2])
else:
if ndim1 >= 1:
shape_rem.append(shape2[-1])
return tuple(shape_rem)

@constexpr
def _check_matmul_shapes(shape1, shape2, prim_name=None):
"""Checks shape1 and shape2 are valid to perform matmul, and returns output shape after broadcasting."""
msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
ndim1, ndim2 = len(shape1), len(shape2)
if ndim1 < 1 or ndim2 < 1:
raise ValueError(f"{msg_prefix} dimension of input operands must be at least 1, but got "
f"the length of shape1: {ndim1}, the length of shape2: {ndim2}.")
if ndim2 >= 2 and shape1[-1] != shape2[-2]:
raise ValueError(f"{msg_prefix} shape1[-1] must be equal to shape2[-2] when the length of shape2 "
f"is greater than or equal to 2, but got shape1[-1]: {shape1[-1]}, "
f"shape2[-2]: {shape2[-2]}.")
shape_out = deque()
for items in zip_longest(reversed(shape1[:-2]), reversed(shape2[:-2]), fillvalue=1):
max_size = max(items)
if any(item not in (1, max_size) for item in items):
raise ValueError(f"{msg_prefix} operands could not be broadcast together with shape1 {shape1} and "
f"shape2 {shape2}.")
shape_out.appendleft(max_size)
return tuple(shape_out)

@constexpr
def _tile_size(shape, out_shape, ndim):
"""Returns tile_size such that shape*tile_size = out_shape"""
size = [1] * ndim
for idx, (i, j) in enumerate(zip(shape, out_shape)):
if i != j:
size[idx] = j
return tuple(size)

@constexpr
"""Returns True if broadcast is necessary for batchmatmul."""
return shape1[:-2] != shape2[:-2]

def _expand(x, ndim):
"""Expand x to ndim from axis, which can be 0 or -1."""
rank_op = _get_cache_prim(P.Rank)()
expand_dims_op = _get_cache_prim(P.ExpandDims)()
while rank_op(x) < ndim:
x = expand_dims_op(x, 0)
return x

"""Broadcasts x from shape_cur to shape_to."""
tile_op = _get_cache_prim(P.Tile)()
size = _tile_size(shape_cur, shape_to, ndim_to)
return tile_op(x, size)

[文档]def matmul(x1, x2):
"""
Returns the matrix product of two tensors.

Note:
Numpy arguments out, casting, order, subok, signature, and extobj are
not supported.
On GPU, the supported dtypes are np.float16 and np.float32.
On CPU, the supported dtypes are np.float16 and np.float32.

Args:
x1 (Tensor): Input tensor, scalar not allowed.
The last dimension of x1 must be the same size as the second last dimension of x2.
And the shape of x1 and x2 could be broadcast.
x2 (Tensor): Input tensor, scalar not allowed.
The last dimension of x1 must be the same size as the second last dimension of x2.
And the shape of x1 and x2 could be broadcast.

Returns:
Tensor or scalar, the matrix product of the inputs. This is a scalar only
when both x1, x2 are 1-d vectors.

Raises:
ValueError: If the last dimension of x1 is not the same size as the
second-to-last dimension of x2, or if a scalar value is passed in.
ValueError: If the shape of x1 and x2 could not broadcast together.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> from mindspore import Tensor, ops
>>> import mindspore
>>> # case 1 : Reasonable application of broadcast mechanism
>>> x1 = Tensor(np.arange(2*3*4).reshape(2, 3, 4), mindspore.float32)
>>> x2 = Tensor(np.arange(4*5).reshape(4, 5), mindspore.float32)
>>> output = ops.matmul(x1, x2)
>>> print(output)
[[[  70.   76.   82.   88.   94.]
[ 190.  212.  234.  256.  278.]
[ 310.  348.  386.  424.  462.]]
[[ 430.  484.  538.  592.  646.]
[ 550.  620.  690.  760.  830.]
[ 670.  756.  842.  928. 1014.]]]
>>> print(output.shape)
(2, 3, 5)
>>> # case 2 : the rank of x1 is 1
>>> x1 = Tensor(np.ones([1, 2]), mindspore.float32)
>>> x2 = Tensor(np.ones([2,]), mindspore.float32)
>>> output = ops.matmul(x1, x2)
>>> print(output)
[2.]
>>> print(output.shape)
(1,)
"""
dtype_op = _get_cache_prim(P.DType)()
rank_op = _get_cache_prim(P.Rank)()
shape_op = _get_cache_prim(P.Shape)()
reshape_op = _get_cache_prim(P.Reshape)()

dtype1 = dtype_op(x1)
dtype2 = dtype_op(x2)
if not _check_same_type(dtype1, dtype2):
x1 = x1.astype(mstype.float32)
x2 = x2.astype(mstype.float32)

ndim1_orig, ndim2_orig = rank_op(x1), rank_op(x2)
shape1_orig, shape2_orig = shape_op(x1), shape_op(x2)
transpose_b = ndim2_orig == 1
shape_backbone = _check_matmul_shapes(shape1_orig, shape2_orig, 'matmul')
# infers the shape of the output
shape_out = shape_backbone + _infer_shape_rem(shape1_orig, shape2_orig,
ndim1_orig, ndim2_orig, transpose_b)

_matmul = _get_cache_prim(P.MatMul)(False, transpose_b)
_batch_matmul = _get_cache_prim(P.BatchMatMul)(False, transpose_b)

x1 = _expand(x1, 2)
x2 = _expand(x2, 2)
if rank_op(x2) == 2:
if rank_op(x1) > 2:
x1 = reshape_op(x1, (-1, shape1_orig[-1]))
res = _matmul(x1, x2)
else:
ndim_aligned = _max(ndim1_orig, ndim2_orig)
x1 = _expand(x1, ndim_aligned)
x2 = _expand(x2, ndim_aligned)
shape1_aligned, shape2_aligned = shape_op(x1), shape_op(x2)
x1 = _broadcast_to(x1, shape1_aligned[:-2], shape_backbone, ndim_aligned)
x2 = _broadcast_to(x2, shape2_aligned[:-2], shape_backbone, ndim_aligned)
res = _batch_matmul(x1, x2)

return reshape_op(res, shape_out)

def baddbmm(x, batch1, batch2, beta=1, alpha=1):
r"""
Performs a batch matrix-matrix product of matrices in batch1 and batch2. input is added to the final result.
The formula is defined as follows:

.. math::
\text{out}_{i} = \beta \text{input}_{i} + \alpha (\text{batch1}_{i} \mathbin{@} \text{batch2}_{i})

Args:
x (Tensor): The tensor to be added.
batch1 (Tensor): The first batch of matrices to be multiplied.
batch2 (Tensor): The second batch of matrices to be multiplied.
alpha: multiplier for batch1 @ batch2.
beta: multiplier for input.

Returns:
Tensor, the output tensor.

Raises:
TypeError: For Baddbmm, inputs are not tensors.
ValueError: If batch1 and batch2 are not 3-D tensors.
TypeError: For inputs of type FloatTensor or DoubleTensor, \
arguments beta and alpha not be real numbers, otherwise not be integers.
ValueError: For Baddbmm, attributes alpha and beta are not real numbers

Supported Platforms:
Ascend GPU CPU

Examples:
>>> input = Tensor(np.ones([1, 3, 3]).astype(np.float32))
>>> batch1 = Tensor(np.ones([1, 3, 4]).astype(np.float32))
>>> batch2 = Tensor(np.ones([1, 4, 3]).astype(np.float32))
>>> output = ops.baddbmm(input, batch1, batch2)
>>> print(output)
[[[5. 5. 5.]
[5. 5. 5.]
[5. 5. 5.]]]
"""
dtypeop = _get_cache_prim(P.DType)()
bmmop = _get_cache_prim(P.BatchMatMul)(False, False)
if not (isinstance(x, Tensor) and isinstance(batch1, Tensor) and isinstance(batch2, Tensor)):
raise TypeError("For Baddbmm, inputs must be all tensors.")
if len(batch1.shape) != 3 or len(batch2.shape) != 3:
raise ValueError("For batch1 and batch2 must be 3-D tensors each containing the same number of matrices, "
f"but got length of batch1:'{len(batch1.shape)}', length of batch2:'{len(batch2.shape)}'.")
input_dtype = dtypeop(x)
if not (input_dtype == dtypeop(batch1) and input_dtype == dtypeop(batch2)):
raise TypeError("For Baddbmm, the inputs should be the same dtype.")
if input_dtype in (mstype.float16, mstype.float32, mstype.float64):
if not (isinstance(alpha, (int, float)) and isinstance(beta, (int, float))):
raise TypeError("For attributes alpha and beta should be real numbers.")
check_is_number(alpha, (int, float))
check_is_number(beta, (int, float))
else:
if not (isinstance(alpha, int) and isinstance(beta, int)):
raise TypeError("For inputs of type not FloatTensor or DoubleTensor, "
"arguments beta and alpha must be integers.")
y = beta * x + alpha * (bmmop(batch1, batch2))
return y

def log2(x):
r"""
Returns a new tensor with the logarithm to the base 2 of the elements of input.

.. math::
y_i = log_2(x_i)

.. warning::
If the input value of operator Log2 is within the range (0, 0.01] or [0.95, 1.05], the output accuracy may
be affacted. If the input value of operator Log2 is less than or equal to 0, it will not raise Error.

.. note::
The dimension of the input Tensor on Ascend should be less than or equal to 8, and the dimension of the
input Tensor on the CPU or GPU should be less than 8.

Args:
x (Tensor): Input Tensor of any dimension. The value must be greater than 0.

Returns:
Tensor, has the same shape and dtype as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is not float16 or float32 or float64 on CPU and GPU, if dtype of x is not float16
or float32 on Ascend.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([2, 4, 8]).astype(np.float16))
>>> output = ops.log2(x)
>>> print(output)
[1. 2. 3.]
"""

dtype_op = _get_cache_prim(P.DType)()

x_dtype = dtype_op(x)
denominator = log_(_make_tensor(2, x_dtype))
frac = log_(x)
output = frac / denominator
return output

def xdivy(x, y):
"""
Divides the first input tensor by the second input tensor element-wise. Returns zero when x is zero.

Inputs of x and y comply with the implicit type conversion rules to make the data types consistent.
The inputs must be two tensors or one tensor and one scalar.
When the inputs are two tensors,
dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
When the inputs are one tensor and one scalar,
the scalar could only be a constant.

Inputs:
- **x** (Union[Tensor, Number, bool]) - The first input is a number, or a bool,
or a tensor whose data type is float16, float32, float64, complex64, complex128 or bool.
- **y** (Union[Tensor, Number, bool]) - The second input is a number,
or a bool when the first input is a tensor, or a tensor whose data type is float16,
float32, float64, complex64, complex128 or bool.

Outputs:
Tensor, the shape is the same as the one after broadcasting,
and the data type is the one with higher precision or higher digits among the two inputs.

Raises:
TypeError: If x and y is not one of the following: Tensor, Number, bool.
TypeError: If dtype of x and 'y' is not in [float16, float32, float64, complex64, complex128, bool].
ValueError: If x could not be broadcast to a tensor with shape of y.
RuntimeError: If the data type of x, y conversion of Parameter is given
but data type conversion of Parameter is not supported.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([2, 4, -1]), mindspore.float32)
>>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
>>> output = ops.xdivy(x, y)
>>> print(output)
[ 1.   2.  -0.5]
"""
return xdivy_(x, y)

[文档]def log1p(x):
r"""
Returns the natural logarithm of one plus the input tensor element-wise.

.. math::
out_i = {log_e}(x_i + 1)

Args:
x (Tensor): The input tensor. With float16 or float32 data type.
The value must be greater than -1.
:math:(N,*) where :math:* means, any number of additional dimensions,
its rank should be less than 8.

Returns:
Tensor, has the same shape as the x.

Raises:
TypeError: If x is not a Tensor.
TypeError: If dtype of x is neither float16 nor float32.

Supported Platforms:
Ascend GPU CPU

Examples:
>>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> output = ops.log1p(x)
>>> print(output)
[0.6931472 1.0986123 1.609438 ]
"""
_log1p = _get_cache_prim(P.Log1p)()
return _log1p(x)

__all__ = [
'absolute',
'abs',
'argmin',
'neg_tensor',
'neg',
'tensor_lt',
'less',
'tensor_le',
'le',
'lerp',
'norm',
'tensor_gt',
'mv',
'outer',
'gt',
'tensor_ge',
'ge',
'tensor_sub',
'sub',
'tensor_mul',
'mul',
'tensor_div',
'div',
'tensor_floordiv',
'floor_div',
'floordiv',
'xdivy',
'tensor_pow',
'pow',
'pows',
'renorm',
'tensor_mod',
'floor_mod',
'floormod',
'tensor_exp',
'exp',
'tensor_expm1',
'expm1',
'equal',
'not_equal',
'ne',
'inplace_update',
'inplace_sub',
'isfinite',
'isnan',
'isclose',
'isreal',
'log',
'linspace',
'matrix_solve',
'same_type_shape',
'maximum',
'minimum',
'floor',
'logical_not',
'logical_or',
'logical_and',
'logsumexp',
'ldexp',
'sin',
'cos',
'tan',
'asin',
'acos',
'atan',
'sinh',
'cosh',
'tanh',
'asinh',
'acosh',
'atanh',
'atan2',
'round',
'bitwise_and',
'bitwise_or',
'bitwise_xor',
'inv',
'invert',
'erf',
'erfc',
'cdist',
'ceil',
'bernoulli',
'bessel_j0',
'bessel_j1',
'bessel_i0',
'bessel_i0e',
'bessel_k0',
'bessel_k0e',
'bessel_y0',
'bessel_y1',
'bessel_i1',
'bessel_i1e',
'bessel_k1',
'bessel_k1e',
'exp2',
'stft',
'truncate_div',
'truncate_mod',
'trunc',
'gumbel_softmax',
'matmul',
'amin',
'amax',
'cummin',
'cummax',
'sparse_segment_mean',
'mean',
'prod',
'log2',
'log1p',
'approximate_equal',
'xlogy'
]
__all__.sort()