mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/function/math_func.py

@@ -26,25 +26,35 @@ import mindspore as ms
 from mindspore import log as logger
 import mindspore.ops as ops
 from mindspore.common import dtype as mstype
+from mindspore.common.generator import default_generator
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.ops.operations._inner_ops import TileSize
-from mindspore.ops.auto_generate import Cummin, BatchMatMul, LinSpaceExt, Norm
+from mindspore.ops.auto_generate import Cummin, BatchMatMul, BernoulliExt, lin_space_ext_op, BitwiseAndScalar,\
+    BitwiseAndTensor, BitwiseOrScalar, BitwiseOrTensor, BitwiseXorScalar, BitwiseXorTensor, RemainderTensorTensor,\
+    RemainderTensorScalar, RemainderScalarTensor
 from mindspore.ops import auto_generate
 from mindspore.ops.operations.math_ops import STFT
 from mindspore.ops.operations.math_ops import LuUnpack
-from mindspore.ops.operations.math_ops import Roll
+from mindspore.ops.auto_generate.pyboost_inner_prim import roll_impl, cross_impl
 from mindspore.ops.operations.math_ops import Ormqr
 from mindspore.ops.operations.math_ops import DivMod
 from mindspore.ops.operations.array_ops import MatrixSetDiagV3, Transpose
-from mindspore.ops.auto_generate import (minimum, maximum, mul, sin, sinc, sinh, cummax, real, conj, add, sub, cos, cosh,
+from mindspore.ops.auto_generate import (minimum, maximum, mul, sin, sinc, sinh, cummax, real, conj, add, sub, cos,
+                                         cosh, nan_to_num, norm_op, lp_norm_v2_op,
                                          matrix_exp, sqrt, rsqrt, square, trace, nextafter, abs, acos, acosh, angle,
                                          asin, asinh, atan, atan2, atanh, ceil, equal, erf, erfc, erfinv, exp, expm1,
                                          floor, floor_divide, floor_mod, gcd, greater, greater_equal, less, less_equal,
-                                         log, log1p, neg, not_equal, pow, round, isfinite, argmax_ext, mean_ext_op,
-                                         sum_ext_op, prod_ext_op, all, matrix_inverse_ext, atan2_ext, sign)
+                                         log, log1p, neg, not_equal, pow, round_op, isfinite, argmax_ext, mean_ext_op,
+                                         sum_ext_op, prod_ext_op, all, matrix_inverse_ext, atan2_ext, sign, acos_ext,
+                                         acosh_ext, asin_ext, asinh_ext, atan_ext, tan, median_ext_op, median_dim_op,
+                                         xlogy_op, xlogy_scalar_other_op, xlogy_scalar_self_op, trunc, histc_ext)
+
+
+
+from mindspore.ops.auto_generate.gen_ops_def import add_ext, sub_ext, bmm_ext
 from mindspore.ops.auto_generate import tanh
 from mindspore.nn import layer
 from mindspore._checkparam import check_is_number
@@ -133,6 +143,7 @@ transpose_ = P.Transpose()
 xdivy_ = P.Xdivy()
 tensor_div_ = P.Div()
 tensor_divmod_ = DivMod()
+generator_step_ = Tensor(10, mstype.int64)
 
 #####################################
 # Private Operation Functions.
@@ -150,6 +161,7 @@ atan2_ = P.Atan2()
 atan_ = P.Atan()
 atanh_ = P.Atanh()
 batch_matmul_ = BatchMatMul()
+bernoulli_ext_ = BernoulliExt()
 bessel_i0_ = BesselI0()
 bessel_i0e_ = P.BesselI0e()
 bessel_i1_ = BesselI1()
@@ -217,9 +229,7 @@ slice_ = P.Slice()
 size_ = P.Size()
 scalar_to_tensor_ = P.ScalarToTensor()
 shape_ = P.Shape()
-sign_ = P.Sign()
 sparse_segment_mean_ = SparseSegmentMean()
-tan_ = P.Tan()
 tanh_ = P.Tanh()
 tensor_round_ = P.Round()
 tile_ = P.Tile()
@@ -230,12 +240,20 @@ truncate_mod_ = P.TruncateMod()
 xlogy_ = P.Xlogy()
 zeros_ = P.Zeros()
 zeta_ = P.Zeta()
+bitwise_and_scalar_ = BitwiseAndScalar()
+bitwise_and_tensor_ = BitwiseAndTensor()
+bitwise_or_scalar_ = BitwiseOrScalar()
+bitwise_or_tensor_ = BitwiseOrTensor()
+bitwise_xor_scalar_ = BitwiseXorScalar()
+bitwise_xor_tensor_ = BitwiseXorTensor()
 
 
 #####################################
 # Element-wise Operation Functions.
 #####################################
-
+remainder_tensor_tensor_ = RemainderTensorTensor()
+remainder_tensor_scalar_ = RemainderTensorScalar()
+remainder_scalar_tensor_ = RemainderScalarTensor()
 
 def addn(x):
     """
@@ -1558,22 +1576,41 @@ def t(input):
     return input
 
 
-def tan(input):
+def xlogy(input, other):
     r"""
-    Computes tangent of `input` element-wise.
+    Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
+    Returns zero when `input` is zero.
 
     .. math::
 
-        out_i = \tan(input_i)
+        out_i = input_{i}\ln{other_{i}}
+
+    Inputs of `input` and `other` 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.
+
+    .. warning::
+        - On Ascend, the data type of `input` and `other` must be float16 or float32.
 
     Args:
-        input (Tensor): The input Tensor, valid for any dimensions.
+        input (Union[Tensor, numbers.Number, bool]): The first input is a numbers.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        other (Union[Tensor, numbers.Number, bool]): The second input is a numbers.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, has the same shape as `input`.
+        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 `input` is not a Tensor.
+        TypeError: If `input` and `other` is not a numbers.Number or a bool or a Tensor.
+        TypeError: If dtype of `input` and `other` is not in [float16, float32, float64, complex64, complex128].
+        ValueError: If `input` could not be broadcast to a tensor with shape of `other`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1582,52 +1619,51 @@ def tan(input):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([-1.0, 0.0, 1.0]), mindspore.float32)
-        >>> output = ops.tan(input)
+        >>> input = Tensor(np.array([-5, 0, 4]), mindspore.float32)
+        >>> other = Tensor(np.array([2, 2, 2]), mindspore.float32)
+        >>> output = ops.xlogy(input, other)
         >>> print(output)
-        [-1.5574081 0. 1.5574081]
+        [-3.465736   0.        2.7725887]
     """
-    return tan_(input)
+    if isinstance(input, Tensor) and isinstance(other, Tensor) and input.dtype == mstype.bool_ \
+            and other.dtype == mstype.bool_:
+        input = input.astype(mstype.float32)
+        other = other.astype(mstype.float32)
+    return xlogy_(input, other)
 
 
-def xlogy(input, other):
+def xlogy_ext(input, other):
     r"""
-    Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
+    Computes the first input multiplied by the logarithm of second input element-wise.
     Returns zero when `input` is zero.
 
     .. math::
 
-        out_i = input_{i}\ln{other_{i}}
+        out_i = input_{i}\log{other_{i}}
 
     Inputs of `input` and `other` 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.
-
-    .. warning::
-        - On Ascend, the data type of `input` and `other` must be float16 or float32.
 
     Args:
-        input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
+        input (Union[Tensor, numbers.Number, bool]): The first input is a numbers.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
-        other (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\_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        other (Union[Tensor, numbers.Number, bool]): The second input is a numbers.Number or
+            a bool or a tensor whose data type is number or bool when the first input is a tensor.
+            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 `input` and `other` is not a number.Number or a bool or a Tensor.
-        TypeError: If dtype of `input` and `other` is not in [float16, float32, float64, complex64, complex128].
+        TypeError: If `input` and `other` is not a numbers.Number or a bool or a Tensor.
         ValueError: If `input` could not be broadcast to a tensor with shape of `other`.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
         >>> import mindspore
@@ -1635,16 +1671,17 @@ def xlogy(input, other):
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([-5, 0, 4]), mindspore.float32)
         >>> other = Tensor(np.array([2, 2, 2]), mindspore.float32)
-        >>> output = ops.xlogy(input, other)
+        >>> output = ops.xlogy_ext(input, other)
         >>> print(output)
         [-3.465736   0.        2.7725887]
     """
-    if isinstance(input, Tensor) and isinstance(other, Tensor) and input.dtype == mstype.bool_ \
-            and other.dtype == mstype.bool_:
-        input = input.astype(mstype.float32)
-        other = other.astype(mstype.float32)
-    return xlogy_(input, other)
-
+    if isinstance(input, Tensor) and isinstance(other, Tensor):
+        return xlogy_op(input, other)
+    if isinstance(input, Tensor) and isinstance(other, (float, int, bool)):
+        return xlogy_scalar_other_op(input, other)
+    if isinstance(input, (float, int, bool)) and isinstance(other, Tensor):
+        return xlogy_scalar_self_op(input, other)
+    raise TypeError(f"For 'xlogy', at least one of input and other should be Tensor.")
 
 def arccosh(input):
     r"""
@@ -1665,6 +1702,16 @@ def arccosh(input):
     return acosh_(input)
 
 
+def arccosh_ext(input):
+    r"""
+    Alias for :func:`mindspore.ops.acosh_ext`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return acosh_ext(input)
+
+
 def arcsin(x):
     r"""
     Alias for :func:`mindspore.ops.asin`.
@@ -1675,6 +1722,16 @@ def arcsin(x):
     return asin_(x)
 
 
+def arcsin_ext(x):
+    r"""
+    Alias for :func:`mindspore.ops.asin_ext`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return asin_ext(x)
+
+
 def arctan(input):
     r"""
     Alias for :func:`mindspore.ops.atan`.
@@ -1694,6 +1751,16 @@ def arctan(input):
     return atan_(input)
 
 
+def arctan_ext(input):
+    r"""
+    Alias for :func:`mindspore.ops.atan_ext`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return atan_ext(input)
+
+
 def arctan2(input, other):
     r"""
     Alias for :func:`mindspore.ops.atan2`.
@@ -1790,6 +1857,16 @@ def arccos(input):
     return acos(input)
 
 
+def arccos_ext(input):
+    """
+    Alias for :func:`mindspore.ops.acos_ext` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return acos_ext(input)
+
+
 def arcsinh(input):
     r"""
     Alias for :func:`mindspore.ops.asinh`.
@@ -1800,6 +1877,16 @@ def arcsinh(input):
     return asinh(input)
 
 
+def arcsinh_ext(input):
+    r"""
+    Alias for :func:`mindspore.ops.asinh_ext`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return asinh_ext(input)
+
+
 def arctanh(input):
     r"""
     Alias for :func:`mindspore.ops.atanh`.
@@ -1850,6 +1937,46 @@ def bitwise_and(input, other):
     return bitwise_and_(input, other)
 
 
+def bitwise_and_ext(input, other):
+    r"""
+    Returns bitwise `and` of two tensors element-wise.
+
+    .. math::
+
+        out_i = input_{i} \wedge other_{i}
+
+    Note:
+        Args of `input` and `other` 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:
+        input (Tensor): The input tensor.
+        other (Tensor, Number.number): The input tensor or scalar. It has the same shape
+            with `input` or its shape is able to broadcast with `input`.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
+        >>> other = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
+        >>> output = ops.bitwise_and_ext(input, other)
+        >>> print(output)
+        [ 0  0  1 -1  1  0  1]
+    """
+    if not isinstance(other, Tensor):
+        return bitwise_and_scalar_(input, other)
+    return bitwise_and_tensor_(input, other)
+
+
 def bitwise_or(input, other):
     r"""
     Returns bitwise `or` of two tensors element-wise.
@@ -1890,6 +2017,46 @@ def bitwise_or(input, other):
     return bitwise_or_(input, other)
 
 
+def bitwise_or_ext(input, other):
+    r"""
+    Returns bitwise `or` of two tensors element-wise.
+
+    .. math::
+
+        out_i = input_{i} \mid other_{i}
+
+    Note:
+        Args of `input` and `other` 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:
+        input (Tensor): The input tensor.
+        other (Tensor, Number.number): The input tensor or scalar. It has the same shape
+            with `input` or its shape is able to broadcast with `input`.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
+        >>> other = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
+        >>> output = ops.bitwise_or_ext(input, other)
+        >>> print(output)
+        [ 0  1  1 -1 -1  3  3]
+    """
+    if not isinstance(other, Tensor):
+        return bitwise_or_scalar_(input, other)
+    return bitwise_or_tensor_(input, other)
+
+
 def bitwise_xor(input, other):
     r"""
     Returns bitwise `xor` of two tensors element-wise.
@@ -1930,6 +2097,46 @@ def bitwise_xor(input, other):
     return bitwise_xor_(input, other)
 
 
+def bitwise_xor_ext(input, other):
+    r"""
+    Returns bitwise `xor` of two tensors element-wise.
+
+    .. math::
+
+        out_i = input_{i} \oplus other_{i}
+
+    Note:
+        Args of `input` and `other` 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:
+        input (Tensor): The input tensor.
+        other (Tensor, Number.number): The input tensor or scalar. It has the same shape
+            with `input` or its shape is able to broadcast with `input`.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
+        >>> other = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
+        >>> output = ops.bitwise_xor_ext(input, other)
+        >>> print(output)
+        [ 0  1  0  0 -2  3  2]
+    """
+    if not isinstance(other, Tensor):
+        return bitwise_xor_scalar_(input, other)
+    return bitwise_xor_tensor_(input, other)
+
+
 def bitwise_left_shift(input, other):
     r"""
     Perform a left bitwise shift operation on the `input` element-wise, where the number of bits to shift is
@@ -2555,38 +2762,38 @@ def linspace_ext(start, end, steps, *, dtype=None):
         \end{aligned}
 
     Args:
-        start (Union[Tensor, Number]): Start value of interval.
-          If `start` is Tensor, data type must be float32 or float64 and with shape of 0-D.
-        end (Union[Tensor, Number]): Last value of interval.
-          If `end` is Tensor, data type must be float32 or float64 and with shape of 0-D.
-        steps (Union[Tensor, int]): Number of ticks in the interval, inclusive of start and end.
-            Must be positive int number or 0D int32/int64 Tensor.
+        start (Union[float, int]): Start value of interval.
+            It can be a float or integer.
+        end (Union[float, int]): Last value of interval.
+            It can be a float or integer.
+        steps (int): Number of ticks in the interval, inclusive of start and end.
+            Must be positive integer.
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The output Tensor data type. Default: ``None`` , the data type of output
-            Tensor is float32.
+        dtype (mindspore.dtype, optional): The output Tensor data type. Default: ``None`` ,
+            in which case the data type of output Tensor is float32.
 
     Returns:
-        Tensor, has the shape of :math:`(steps,)`.
+        Tensor, has the shape of :math:`(steps,)`, with dtype specified by `dtype`.
 
     Raises:
-        TypeError: If dtype of `start` or dtype of `end` is not supported.
-        ValueError: If shape of `start` or shape of `end` is not 0-D.
-        TypeError: If `steps` is not int or 0D int32/int64 Tensor.
-        ValueError: If `steps` is not positive int number.
+        TypeError: If type of `start` or dtype of `end` is not supported.
+        ValueError: If `steps` is not positive integer.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> start = Tensor(1, mindspore.float32)
-        >>> end = Tensor(10, mindspore.float32)
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> start = 1
+        >>> end = 10
         >>> steps = 5
-        >>> output = ops.function.math_func.linspace_ext(start, end, steps, dtype=mindspore.float32)
+        >>> output = ops.function.math_func.linspace_ext(start, end, steps, dtype=ms.float32)
         >>> print(output)
         [ 1.    3.25  5.5   7.75 10.  ]
     """
-    return _get_cache_prim(LinSpaceExt)()(start, end, steps, dtype)
+    return lin_space_ext_op(start, end, steps, dtype)
 
 
 def det(input):
@@ -2872,34 +3079,6 @@ def truncate_mod(x, y):
     return truncate_mod_(x, y)
 
 
-def trunc(input):
-    r"""
-    Returns a new tensor with the truncated integer values of the elements of the input tensor.
-
-    Args:
-        input (Tensor): The input tensor.
-
-    Returns:
-        Tensor, the same shape and data type as the input.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]),mindspore.float32)
-        >>> output = ops.trunc(x)
-        >>> print(output)
-        [3. 0. 0. -3.]
-    """
-    return trunc_(input)
-
-
 def ldexp(x, other):
     """
     Multiplies input Tensor by :math:`2^{other}` element-wise.
@@ -2996,6 +3175,7 @@ def logit(input, eps=None):
     logit_ = _get_cache_prim(P.Logit)(eps)
     return logit_(input)
 
+
 #####################################
 # Comparison Operation Functions.
 #####################################
@@ -3031,8 +3211,8 @@ def le(input, other):
     Args:
         input (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/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (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\_.
@@ -3081,8 +3261,8 @@ def gt(input, other):
     Args:
         input (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/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ .
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ .
         other (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\_.
@@ -3460,66 +3640,6 @@ def is_complex(input):
     return input.dtype in mstype.complex_type
 
 
-def nan_to_num(input, nan=0.0, posinf=None, neginf=None):
-    """
-    Replace the `NaN`, positive infinity and negative infinity values in 'input' with the
-    specified values in `nan`, `posinf` and `neginf` respectively.
-
-    Args:
-        input (Tensor): The shape of tensor is :math:`(input_1, input_2, ..., input_R)`.
-            With float32 or float16 data type.
-        nan (float): The replace value of 'NaN'. Default value is 0.0.
-        posinf (float): the value to replace positive infinity values with. Default: ``None``,
-            replacing positive infinity with the maximum value supported by the data type of `input`.
-        neginf (float): the value to replace negative infinity values with. Default: ``None``,
-            replacing negative infinity with the minimum value supported by the data type of `input`.
-
-    Returns:
-        Tensor, has the same shape and dtype as the `input`.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not float16 or float32.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([float('nan'), float('inf'), -float('inf'), 5.0]), mindspore.float32)
-        >>> output = ops.nan_to_num(input, 1.0, 2.0, 3.0)
-        >>> print(output)
-        [1.  2.  3.  5.0]
-    """
-    if not isinstance(input, (Tensor, Tensor_)):
-        raise TypeError("the input x must be Tensor!")
-    if nan is not None:
-        if not isinstance(nan, float):
-            raise TypeError("the parameter nan's dtype must be float.")
-    else:
-        nan = 0.0
-    if posinf is not None:
-        if not isinstance(posinf, float):
-            raise TypeError("the parameter posinf's dtype must be float.")
-    else:
-        if input.dtype == mstype.float16:
-            posinf = (float)(np.finfo(np.float16).max)
-        elif input.dtype == mstype.float32:
-            posinf = (float)(np.finfo(np.float32).max)
-    if neginf is not None:
-        if not isinstance(neginf, float):
-            raise TypeError("the parameter neginf's dtype must be float.")
-    else:
-        if input.dtype == mstype.float16:
-            neginf = (float)(np.finfo(np.float16).min)
-        elif input.dtype == mstype.float32:
-            neginf = (float)(np.finfo(np.float32).min)
-    _nan_to_num = _get_cache_prim(NanToNum)(nan=nan, posinf=posinf, neginf=neginf)
-    return _nan_to_num(input)
-
-
 def fmax(input, other):
     r"""
     Computes the maximum of input tensors element-wise.
@@ -3606,6 +3726,51 @@ def fmin(input, other):
     return fmin_(input, other)
 
 
+def median_ext(input, dim=None, keepdim=False):
+    r"""
+    Output the median on the specified dimension ``dim`` and its corresponding index.
+    If ``dim`` is None, calculate the median of all elements in the Tensor.
+
+    Args:
+        input (Tensor): A Tensor of any dimension whose data type is uint8, int16, int32, int64, float16 or float32.
+        dim (int, optional): Specify the axis for calculation. Default: ``None`` .
+        keepdim (bool, optional): Whether the output tensor need to retain ``dim`` dimension or not.
+            Default: ``False`` .
+
+    Returns:
+        - y (Tensor) - Output median, with the same data type as ``input`` .
+
+          - If ``dim`` is ``None`` , ``y`` only has one element.
+          - If ``keepdim`` is ``True`` , the ``y`` has the same shape as the ``input`` except the shape
+            of ``y`` in dimension `dim` is size 1.
+          - Otherwise, the ``y`` lacks `dim` dimension than input.
+
+        - indices (Tensor) - The index of the median. Shape is consistent with ``y`` , with a data type of int64.
+
+    Raises:
+        TypeError: If dtype of ``input`` is not one of the following: uint8, int16, int32, int64, float16 or float32.
+        TypeError: If input ``input`` is not a Tensor.
+        TypeError: If ``dim`` is not a int.
+        TypeError: If ``keepdim`` is not a bool.
+        ValueError: If ``dim`` is not in range of [-x.dim, x.dim-1].
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[0.57, 0.11, 0.21],[0.38, 0.50, 0.57], [0.36, 0.16, 0.44]]).astype(np.float32))
+        >>> y = ops.function.math_func.median_ext(x, dim=0, keepdim=False)
+        >>> print(y)
+        (Tensor(shape=[3], dtype=Float32, value= [ 3.79999995e-01,  1.59999996e-01,  4.39999998e-01]),
+        Tensor(shape=[3], dtype=Int64, value= [1, 2, 2]))
+    """
+    if dim is None:
+        return median_ext_op(input)
+    return median_dim_op(input, dim, keepdim)
+
+
 def median(input, axis=-1, keepdims=False):
     r"""
     Computes the median and indices of input tensor.
@@ -3959,7 +4124,7 @@ def histc(input, bins=100, min=0., max=0.):
         max (int, float, optional): An optional float of the upper end of the range (inclusive). Default: ``0.0`` .
 
     Returns:
-        Tensor, 1-D Tensor with type int32.
+        1-D Tensor. If the input is int32, the output returns int32, otherwise it returns float32.
 
     Raises:
         TypeError: If `input` is not a Tensor.
@@ -3977,7 +4142,7 @@ def histc(input, bins=100, min=0., max=0.):
         >>> x = Tensor([1., 2, 1])
         >>> y = ops.histc(x, bins=4, min=0.0, max=3.0)
         >>> print(y)
-        [0 2 1 0]
+        [0. 2. 1. 0.]
     """
     if not isinstance(min, (int, float)):
         raise TypeError(f"For 'histc', parameter 'min' must be an int or float, but got {type(min)}.")
@@ -4049,7 +4214,7 @@ def logaddexp(input, other):
 
     Args:
         input (Tensor): Input Tensor. The dtype of `input` must be float.
-        other (Tensor): Input Tensor. The dtype of `input` must be float.
+        other (Tensor): Input Tensor. The dtype of `other` must be float.
             If the shape of `input` is not equal to the shape of `other`,
             they must be broadcastable to a common shape (which becomes the shape of the output).
 
@@ -4078,7 +4243,7 @@ def logaddexp(input, other):
     if not isinstance(other, (Tensor, Tensor_)):
         raise TypeError(f"For logaddexp, the other must be a Tensor, but got {type(other)}.")
     if not ops.is_floating_point(input) or not ops.is_floating_point(other):
-        raise TypeError(f"For logaddexp2, the dtype of 'input' and 'other' must be float,"
+        raise TypeError(f"For logaddexp, the dtype of 'input' and 'other' must be float,"
                         f"but got {input.dtype} and {other.dtype}.")
     m = maximum(input, other)
     abs_val = abs(input - other)
@@ -4991,7 +5156,7 @@ def bernoulli(input, p=0.5, seed=None):
             positive integer. Default: ``None`` , means using the current timestamp.
 
     Returns:
-        output (Tensor), with the same shape and type as `input` .
+        output (Tensor), with the same shape and type as `input`.
 
     Raises:
         TypeError: If dtype of `input` is not one of: int8, uint8, int16, int32, int64, bool, float32, float64.
@@ -5027,6 +5192,61 @@ def bernoulli(input, p=0.5, seed=None):
     return bernoulli_(input, p)
 
 
+def bernoulli_ext(input, *, generator=None):
+    r"""
+    Sample from the Bernoulli distribution and randomly set the i^{th} element of the `output` to (0 or 1) according to
+    the i^{th} probability value given in the `input`.
+
+    .. math::
+        output_{i} \sim Bernoulli(p=input_{i})
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor of Bernoulli distribution, where the i^{th} element 'input_{i}' represents the
+            probability that the corresponding output element 'output_{i}' is set to '1', therefore each element in
+            'input' have to be in the range '[0,1]'. Supported dtype: float16, float32, float64, bfloat16
+            (only supported by Atlas A2 training series products).
+
+    Keyword Args:
+        generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+            Default: ``None``, uses the default pseudorandom number generator.
+
+    Returns:
+        output (Tensor): The output tensor, with the same shape and dtype as `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is not one of: float16, float32, float64, bfloat16.
+        ValueError: If any element of the `input` is not in the range [0, 1].
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> input_x = Tensor(np.ones((3, 3)), mindspore.float32)
+        >>> output = ops.bernoulli_ext(input_x)
+        >>> print(output)
+        [[ 1. 1. 1.]
+         [ 1. 1. 1.]
+         [ 1. 1. 1.]]
+        >>> input_x = Tensor(np.zeros((3, 3)), mindspore.float32)
+        >>> output = ops.bernoulli_ext(input_x)
+        >>> print(output)
+        [[ 0. 0. 0.]
+         [ 0. 0. 0.]
+         [ 0. 0. 0.]]
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return bernoulli_ext_(input, seed, offset)
+
+
 def bessel_i1(x):
     r"""
     Computes modified Bessel function of the first kind, order 1 element-wise.
@@ -7276,14 +7496,14 @@ def _compute_vector_norm_inf(x, dim, keepdims, norm_func):
     return ret_norm
 
 
-def norm_ext(A, ord=None, dim=None, keepdim=False, *, dtype=None):
+def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
     r"""
     Returns the matrix norm or vector norm of a given tensor.
 
-    `ord` is the calculation mode of norm. The following norm modes are supported.
+    `p` is the calculation mode of norm. The following norm modes are supported.
 
     ====================== ================================ ==========================================
-    `ord`                   norm for matrices               norm for vectors
+    `p`                     norm for matrices               norm for vectors
     ====================== ================================ ==========================================
     `None` (default)        Frobenius norm                   `2`-norm (see below)
     `'fro'`                 Frobenius norm                   -- not supported --
@@ -7291,44 +7511,31 @@ def norm_ext(A, ord=None, dim=None, keepdim=False, *, dtype=None):
     `inf`                   :math:`max(sum(abs(x), dim=1))`  :math:`max(abs(x))`
     `-inf`                  :math:`min(sum(abs(x), dim=1))`  :math:`min(abs(x))`
     `0`                     -- not supported --              :math:`sum(x != 0)`
-    `1`                     :math:`max(sum(abs(x), dim=0))`  as below
-    `-1`                    :math:`min(sum(abs(x), dim=0))`  as below
-    `2`                     largest singular value           as below
-    `-2`                    smallest singular value          as below
     other `int` or `float`  -- not supported --              :math:`sum(abs(x)^{ord})^{(1 / ord)}`
     ====================== ================================ ==========================================
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)` where * is zero or more batch dimensions.
-        ord (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
-            behavior. Default: ``None`` .
+        input (Tensor): The input of LogSigmoid with data type of bfloat16, float16 or float32.
+            The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
+        p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
+            behavior. Default: ``fro`` .
         dim (Union[int, Tuple(int)], optional): calculate the dimension of vector norm or matrix norm.
             Default: ``None`` .
-
-            - When `dim` is int, it will be calculated by vector norm.
-
-            - When `dim` is a 2-tuple, it will be calculated by matrix norm.
-
-            - If `dim` is None and `ord` is None, `A` will be flattened to 1D and the 2-norm
-              of the vector will be calculated.
-
-            - If `dim` is None and `ord` is not None, `A` must be 1D or 2D.
-
         keepdim (bool): whether the output Tensor retains the original dimension. Default: ``False`` .
 
     Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): When set, `A` will be converted to the specified type,
+        dtype (:class:`mindspore.dtype`, optional): When set, `input` will be converted to the specified type,
             `dtype`, before execution, and dtype of returned Tensor will also be `dtype`. Default: ``None`` .
 
     Returns:
-        Tensor, the result of norm calculation on the specified dimension, `dim`, has the same dtype as `A`.
+        Tensor, the result of norm calculation on the specified dimension, `dim`, has the same dtype as `input`.
 
     Raises:
         ValueError: If `dim` is out of range.
         TypeError: If `dim` is neither an int nor a tuple of int.
-        TypeError: If `A` is a vector and `ord` is a str.
-        ValueError: If `A` is a matrices and `ord` is not in valid mode.
-        ValueError: If `A` is a matrices and `ord` is an integer but not in [1, -1, 2, -2].
         ValueError: If two elements of `dim` is same after normalize.
         ValueError: If any elements of `dim` is out of range.
 
@@ -7336,23 +7543,35 @@ def norm_ext(A, ord=None, dim=None, keepdim=False, *, dtype=None):
         ``Ascend``
 
     Note:
-        Currently, it only support `ops.function.math_func.norm_ext(A)`.
+        Currently, it only support `ops.function.math_func.norm_ext(input, p=number)`.
 
     Examples:
         >>> import mindspore as ms
         >>> from mindspore import ops
         >>> data_range = ops.arange(-13, 13, dtype=ms.float32)
-        >>> # Exclude 0 from original data for 0 is invalid input when `ord` is negative.
         >>> x = data_range[data_range != 0]
         >>> y = x.reshape(5, 5)
-        >>> print(ops.function.math_func.norm_ext(x))
+        >>> print(ops.function.math_func.norm_ext(x, 2.0))
         38.327538
-        >>> print(ops.norm(x, 0))
-        25.0
     """
-    norm_ext_op = Norm()
-    return norm_ext_op(A, ord, dim, keepdim, dtype)
-
+    if (dim is not None) or keepdim or (dtype is not None):
+        raise ValueError(f"For `norm_ext`, the value of `dim`, `keepdim` and `dtype` must be default value currently.")
+
+    if isinstance(p, (int, float)):
+        if float(p) in [0.0, 1.0, 2.0, 3.0]:
+            return norm_op(input, p, dim, keepdim, dtype)
+        if input.dtype in [mstype.bfloat16, mstype.float16, mstype.float32]:
+            return lp_norm_v2_op(input, p, dim, keepdim, 0.0)
+        dtype = input.dtype
+        input = ops.cast(input, mstype.float32)
+        return ops.cast(lp_norm_v2_op(input, p, dim, keepdim, 0.0), dtype)
+
+    if p == 'fro':
+        if isinstance(dim, (list, tuple)) and len(dim) > 2:
+            raise ValueError(f"For `norm_ext`, the size of `dim` cannot be greater than 2 "
+                             f"when the mode of norm is `fro`.")
+        return norm_op(input, 2.0, dim, keepdim, dtype)
+    raise ValueError(f"For `norm_ext`, the value of `p` cannot be `{p}` currently.")
 
 def vector_norm(x, ord=2, axis=None, keepdims=False, *, dtype=None):
     r"""
@@ -7822,7 +8041,7 @@ def kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None):
         Tensor, a Kaiser window.
 
     Raises:
-        TypeError: If `window_length` or `beta` is not an integer.
+        TypeError: If `window_length` is not an integer.
         TypeError: If `periodic` is not a variable of Boolean type.
         ValueError: If `window_length` is negative.
 
@@ -8405,6 +8624,50 @@ def baddbmm(input, batch1, batch2, beta=1, alpha=1):
     return y
 
 
+def baddbmm_ext(input, batch1, batch2, *, beta=1, alpha=1):
+    r"""
+    The result is the sum of the input and a batch matrix-matrix product of matrices in batch1 and batch2.
+    The formula is defined as follows:
+
+    .. math::
+        \text{out}_{i} = \beta \text{input}_{i} + \alpha (\text{batch1}_{i} \mathbin{@} \text{batch2}_{i})
+
+    Args:
+        input (Tensor): The input Tensor. When batch1 is a :math:`(C, W, T)` Tensor and batch2 is a
+            :math:`(C, T, H)` Tensor, input must be broadcastable with :math:`(C, W, H)` Tensor.
+        batch1 (Tensor): :math:`batch1` in the above formula. Must be 3-D Tensor, dtype is same as input.
+        batch2 (Tensor): :math:`batch2` in the above formula. Must be 3-D Tensor, dtype is same as input.
+
+    Keyword Args:
+        beta (Union[float, int], optional): multiplier for input. Default: ``1`` .
+        alpha (Union[float, int], optional): multiplier for :math:`batch1 @ batch2`. Default: ``1`` .
+
+    Returns:
+        Tensor, has the same dtype as input, shape will be :math:`(C, W, H)`.
+
+    Raises:
+        TypeError: If the type of `input`, `batch1`, `batch2` is not Tensor.
+        TypeError: If the types of `input`, `batch1`, `batch2` are different.
+        ValueError: If `batch1` and `batch2` are not 3-D tensors.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> 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_ext(input, batch1, batch2)
+        >>> print(output)
+        [[[5. 5. 5.]
+          [5. 5. 5.]
+          [5. 5. 5.]]]
+    """
+    return ops.auto_generate.baddbmm(input, batch1, batch2, beta, alpha)
+
+
 def log2(input):
     r"""
     Returns a new Tensor by taking the base 2 logarithm of the elements in the input Tensor.
@@ -8563,16 +8826,12 @@ def roll(input, shifts, dims=None):
         >>> import mindspore as ms
         >>> from mindspore import ops
         >>> from mindspore import Tensor
-        >>> input_x = Tensor(np.array([0, 1, 2, 3, 4]).astype(np.float32))
-        >>> output = ops.roll(input_x, shifts=2, dims=0)
+        >>> input = Tensor(np.array([0, 1, 2, 3, 4]).astype(np.float32))
+        >>> output = ops.roll(input, shifts=2, dims=0)
         >>> print(output)
         [3. 4. 0. 1. 2.]
     """
-    _shape = input.shape
-    if dims is None:
-        flatten_x = input.reshape(-1)
-        return Roll(shifts, 0)(flatten_x).reshape(_shape)
-    return Roll(shifts, dims)(input)
+    return roll_impl(input, shifts, dims)
 
 
 def xdivy(x, y):
@@ -8752,7 +9011,6 @@ def _check_is_tensor(param_name, input, cls_name):
         raise TypeError(f"For {cls_name}, {param_name} must be a Tensor, but got {type(input)}.")
 
 
-
 def any(input, axis=None, keep_dims=False):
     r"""
     Reduces a dimension of `input` by the "logical OR" of all elements in the dimension, by default. And also can
@@ -8763,7 +9021,7 @@ def any(input, axis=None, keep_dims=False):
         The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
 
     Args:
-        input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
+        input (Tensor): Input Tensor(bool),has the shape :math:`(N, *)` where :math:`*` means,
             any number of additional dimensions.
         axis (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
             Suppose the rank of `input` is r, `axis` must be in the range [-rank(input), rank(input)).
@@ -8785,7 +9043,7 @@ def any(input, axis=None, keep_dims=False):
 
     Raises:
         TypeError: If `keep_dims` is not a bool.
-        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is not a Tensor(bool).
         TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
 
     Supported Platforms:
@@ -8864,6 +9122,59 @@ def remainder(input, other):
     return out
 
 
+def remainder_ext(input, other):
+    r"""
+    Computes the remainder of `input` divided by `other` element-wise. The result has the same sign as the divisor and
+    its absolute value is less than that of `other`.
+
+    Supports broadcasting to a common shape and implicit type promotion.
+
+    .. math::
+
+        remainder(input, other) = input - input.div(other, rounding\_mode="floor") * other
+
+    Note:
+        Complex inputs are not supported. At least one input need to be tensor, but not both are bool tensors.
+
+    Args:
+        input (Union[Tensor, numbers.Number, bool]): The dividend is a numbers.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
+            a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
+            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool\_.
+
+    Returns:
+        Tensor, with dtype promoted and shape broadcasted.
+
+    Raises:
+        TypeError: If `input` and `other` are not of types: (tensor, tensor), (tensor, number), (tensor, bool),
+            (number, tensor) or (bool, tensor).
+        ValueError: If `input` and `other` are not broadcastable.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([-4.0, 5.0, 6.0]).astype(np.float32))
+        >>> y = Tensor(np.array([3.0, 2.0, 3.0]).astype(np.float64))
+        >>> output = ops.remainder_ext(x, y)
+        >>> print(output)
+        [2.  1.  0.]
+    """
+
+    if isinstance(input, Tensor) and isinstance(other, Tensor):
+        return remainder_tensor_tensor_(input, other)
+    if isinstance(input, Tensor) and isinstance(other, (float, int, bool)):
+        return remainder_tensor_scalar_(input, other)
+    if isinstance(input, (float, int, bool)) and isinstance(other, Tensor):
+        return remainder_scalar_tensor_(input, other)
+    raise TypeError(f"For 'remainder', inputs should either be two tensors, or a tensor and a scalar.")
+
+
 def accumulate_n(x):
     r"""
     Computes accumulation of all input tensors element-wise.
@@ -9344,8 +9655,7 @@ def cross(input, other, dim=None):
     """
     if dim is None:
         dim = -65530
-    cross_op = _get_cache_prim(P.Cross)(dim=dim)
-    return cross_op(input, other)
+    return cross_impl(input, other, dim)
 
 
 def _einsum_convert_num_to_char(num):
@@ -9874,10 +10184,6 @@ def logical_xor(input, other):
         >>> print(output)
         [False True]
     """
-    if isinstance(input, Tensor) and input.dtype != mstype.bool_:
-        input = input.astype(mstype.bool_)
-    if isinstance(other, Tensor) and other.dtype != mstype.bool_:
-        other = other.astype(mstype.bool_)
     return logical_xor_(input, other)
 
 
@@ -11598,6 +11904,50 @@ def batch_dot(x1, x2, axes=None):
     return final_result
 
 
+def round(input, *, decimals=0):
+    r"""
+    Returns half to even of a tensor element-wise.
+
+    .. math::
+        out_i \approx input_i
+
+    .. note::
+        The input data types supported by the Ascend platform include
+        bfloat16 (Atlas training series products are not supported), float16, float32, float64, int32, and int64.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Keyword Args:
+        decimals (int, optional): Number of decimal places to round to (default: 0). If decimals is negative,
+            it specifies the number of positions to the left of the decimal point. It supports converting the
+            single-element tensor to an int.
+
+    Returns:
+        Tensor, has the same shape and type as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
+        >>> output = ops.round(input)
+        >>> print(output)
+        [ 1.  2.  2.  2. -4.]
+        >>> input = Tensor(np.array([0.81, 1.52, 2.35, 2.53, -4.57]), mindspore.float32)
+        >>> output = ops.round(input, decimals=1)
+        >>> print(output)
+        [ 0.8  1.5  2.4  2.5 -4.6]
+    """
+    return round_op(input, decimals)
+
+
 __all__ = [
     'addn',
     'absolute',
@@ -11821,6 +12171,7 @@ __all__ = [
     'accumulate_n',
     'iou',
     'baddbmm',
+    'baddbmm_ext',
     'bmm',
     'trapz',
     'cholesky',