# Copyright 2022 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""sparse unary function api"""
from mindspore.common import CSRTensor, COOTensor
from mindspore.ops.composite.multitype_ops._constexpr_utils import raise_type_error
from mindspore.ops.function import math_func, nn_func
[docs]def csr_cos(x: CSRTensor) -> CSRTensor:
r"""
Computes cosine of input element-wise.
.. math::
out_i = \cos(x_i)
.. warning::
Currently support data types float16 and float32. If use float64, there may be a problem of missing precision.
Args:
x (CSRTensor): Input CSRTensor.
Returns:
CSRTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16, float32 or float64, complex64,
complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_cos(x)
>>> print(output.values)
[ 0.5403023 -0.41614684]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_cos')
return CSRTensor(x.indptr, x.indices, math_func.cos(x.values), x.shape)
[docs]def coo_cos(x: COOTensor) -> COOTensor:
r"""
Computes cosine of input element-wise.
.. math::
out_i = \cos(x_i)
.. warning::
If use float64, there may be a problem of missing precision.
Args:
x (COOTensor): Input COOTensor.
Returns:
COOTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16, float32 or float64, complex64,
complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_cos(x)
>>> print(output.values)
[ 0.5403023 -0.41614684]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_cos')
return COOTensor(x.indices, math_func.cos(x.values), x.shape)
[docs]def csr_tan(x: CSRTensor) -> CSRTensor:
r"""
Computes tangent of `x` element-wise.
.. math::
out_i = \tan(x_i)
Args:
x (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_tan(x)
>>> print(output.values)
[-1.5574077 -2.1850398]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_tan')
return CSRTensor(x.indptr, x.indices, math_func.tan(x.values), x.shape)
[docs]def coo_tan(x: COOTensor) -> COOTensor:
r"""
Computes tangent of `x` element-wise.
.. math::
out_i = \tan(x_i)
Args:
x (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_tan(x)
>>> print(output.values)
[-1.5574077 -2.1850398]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_tan')
return COOTensor(x.indices, math_func.tan(x.values), x.shape)
[docs]def csr_exp(x: CSRTensor) -> CSRTensor:
"""
Returns csr_exponential of a CSRTensor element-wise.
.. math::
out_i = e^{x_i}
Args:
x (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_exp(x)
>>> print(output.values)
[0.36787948 7.3890557 ]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_exp')
return CSRTensor(x.indptr, x.indices, math_func.exp(x.values), x.shape)
[docs]def coo_exp(x: COOTensor) -> COOTensor:
"""
Returns the element-wise exponential of a COOTensor.
.. math::
out_i = e^{x_i}
Args:
x (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_exp(x)
>>> print(output.values)
[0.36787948 7.3890557 ]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_exp')
return COOTensor(x.indices, math_func.exp(x.values), x.shape)
[docs]def csr_inv(x: CSRTensor) -> CSRTensor:
r"""
Computes Reciprocal of input CSRTensor element-wise.
.. math::
out_i = \frac{1}{x_{i} }
Args:
x (CSRTensor): Input CSRTensor. Must be one of the following types: float16, float32 or int32.
Returns:
CSRTensor, has the same type and shape as input shape value.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not one of float16, float32, int32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_inv(x)
>>> print(output.values)
[-1. 0.5]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_inv')
return CSRTensor(x.indptr, x.indices, math_func.inv(x.values), x.shape)
[docs]def coo_inv(x: COOTensor) -> COOTensor:
r"""
Computes Reciprocal of input COOTensor element-wise.
.. math::
out_i = \frac{1}{x_{i} }
Args:
x (COOTensor): Input COOTensor. Must be one of the following types: float16, float32 or int32.
Returns:
COOTensor, has the same type and shape as input shape value.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not one of float16, float32, int32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_inv(x)
>>> print(output.values)
[-1. 0.5]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_inv')
return COOTensor(x.indices, math_func.inv(x.values), x.shape)
[docs]def csr_relu(x: CSRTensor) -> CSRTensor:
r"""
Computes ReLU (Rectified Linear Unit activation function) of input csr_tensors element-wise.
It returns max(x, 0) element-wise. Specially, the neurons with the negative output
will be suppressed and the active neurons will stay the same.
.. math::
ReLU(x) = (x)^+ = \max(0, x)
Args:
x (CSRTensor): Input CSRTensor.
Returns:
CSRTensor, with the same dtype and shape as the `x`.
Raises:
TypeError: If dtype of `x` is not a number.
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_relu(x)
>>> print(output.values)
[0. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_relu')
return CSRTensor(x.indptr, x.indices, nn_func.relu(x.values), x.shape)
[docs]def coo_relu(x: COOTensor) -> COOTensor:
r"""
Computes ReLU (Rectified Linear Unit activation function) of input coo_tensors element-wise.
It returns :math:`\max(x,\ 0)` element-wise. Specially, the neurons with the negative output
will be suppressed and the active neurons will stay the same.
.. math::
ReLU(x) = (x)^+ = \max(0, x)
Args:
x (COOTensor): Input COOTensor with shape :math:`(N, *)`, where :math:`*`
means any number of additional dimensions. Its dtype is
`number <https://www.mindspore.cn/docs/en/r2.4.0/api_python/mindspore/mindspore.dtype.html>`_.
Returns:
COOTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If dtype of `x` is not a number.
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_relu(x)
>>> print(output.values)
[0. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_relu')
return COOTensor(x.indices, nn_func.relu(x.values), x.shape)
[docs]def csr_expm1(x: CSRTensor) -> CSRTensor:
"""
Returns exponential then minus 1 of a CSRTensor element-wise.
.. math::
out_i = e^{x_i} - 1
Args:
x (CSRTensor): The input CSRTensor with a dtype of float16 or float32.
Returns:
CSRTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_expm1(x)
>>> print(output.values)
[-0.63212055 6.389056 ]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_expm1')
return CSRTensor(x.indptr, x.indices, math_func.expm1(x.values), x.shape)
[docs]def coo_expm1(x: COOTensor) -> COOTensor:
"""
Returns exponential then minus 1 of a COOTensor element-wise.
.. math::
out_i = e^{x_i} - 1
Args:
x (COOTensor): The input COOTensor with a dtype of float16 or float32.
Returns:
COOTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_expm1(x)
>>> print(output.values)
[-0.63212055 6.389056 ]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_expm1')
return COOTensor(x.indices, math_func.expm1(x.values), x.shape)
[docs]def csr_isfinite(x: CSRTensor) -> CSRTensor:
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 (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_isfinite(x)
>>> print(output.values)
[ True True]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_isfinite')
return CSRTensor(x.indptr, x.indices, math_func.isfinite(x.values), x.shape)
[docs]def coo_isfinite(x: COOTensor) -> COOTensor:
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 (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_isfinite(x)
>>> print(output.values)
[ True True]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_isfinite')
return COOTensor(x.indices, math_func.isfinite(x.values), x.shape)
[docs]def csr_asin(x: CSRTensor) -> CSRTensor:
r"""
Computes arcsine of input csr_tensors element-wise.
.. math::
out_i = \sin^{-1}(x_i)
Args:
x (CSRTensor): Input CSRTensor. The data types should be one of the following types:
float16, float32, float64.
Returns:
CSRTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16, float32, float64.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_asin(x)
>>> print(output.values)
[-1.5707964 nan]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_asin')
return CSRTensor(x.indptr, x.indices, math_func.asin(x.values), x.shape)
[docs]def coo_asin(x: COOTensor) -> COOTensor:
r"""
Computes arcsine of input coo_tensors element-wise.
.. math::
out_i = \sin^{-1}(x_i)
Args:
x (COOTensor): Input COOTensor. The shape of COOTensor is :math:`(N,*)` ,
where :math:`*` means any number of additional dimensions.
The data type should be one of the following types: float16, float32, float64, complex64, complex128.
Returns:
COOTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16, float32, float64, complex64, complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_asin(x)
>>> print(output.values)
[-1.5707964 nan]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_asin')
return COOTensor(x.indices, math_func.asin(x.values), x.shape)
[docs]def csr_sqrt(x: CSRTensor) -> CSRTensor:
r"""
Returns sqrt of a CSRTensor element-wise.
.. math::
out_{i} = \sqrt{x_{i}}
Args:
x (CSRTensor): The input CSRTensor with a dtype of Number.
Returns:
CSRTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_sqrt(x)
>>> print(output.values)
[ nan 1.4142135]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_sqrt')
return CSRTensor(x.indptr, x.indices, math_func.sqrt(x.values), x.shape)
[docs]def coo_sqrt(x: COOTensor) -> COOTensor:
r"""
Returns sqrt of a COOTensor element-wise.
.. math::
out_{i} = \sqrt{x_{i}}
Args:
x (COOTensor): The input COOTensor with a dtype of Number.
Returns:
COOTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_sqrt(x)
>>> print(output.values)
[ nan 1.4142135]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_sqrt')
return COOTensor(x.indices, math_func.sqrt(x.values), x.shape)
[docs]def csr_log(x: CSRTensor) -> CSRTensor:
r"""
Returns the natural logarithm of a CSRTensor element-wise.
.. math::
y_i = \log_e(x_i)
.. 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 (CSRTensor): The value must be greater than 0.
Returns:
CSRTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
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:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_log(x)
>>> print(output.values)
[ nan 0.69314575]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_log')
return CSRTensor(x.indptr, x.indices, math_func.log(x.values), x.shape)
[docs]def coo_log(x: COOTensor) -> COOTensor:
r"""
Returns the natural logarithm of a COOTensor element-wise.
.. math::
y_i = \log_e(x_i)
.. 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 (COOTensor): The value must be greater than 0.
Returns:
COOTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
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:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_log(x)
>>> print(output.values)
[ nan 0.69314575]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_log')
return COOTensor(x.indices, math_func.log(x.values), x.shape)
[docs]def csr_isnan(x: CSRTensor) -> CSRTensor:
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 (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_isnan(x)
>>> print(output.values)
[False False]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_isnan')
return CSRTensor(x.indptr, x.indices, math_func.isnan(x.values), x.shape)
[docs]def coo_isnan(x: COOTensor) -> COOTensor:
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 (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_isnan(x)
>>> print(output.values)
[False False]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_isnan')
return COOTensor(x.indices, math_func.isnan(x.values), x.shape)
[docs]def csr_acos(x: CSRTensor) -> CSRTensor:
r"""
Computes arccosine of input csr_tensors element-wise.
.. math::
out_i = \cos^{-1}(x_i)
Args:
x (CSRTensor): Input CSRTensor.
Returns:
CSRTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16, float32 or float64, complex64,
complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_acos(x)
>>> print(output.values)
[3.1415927 nan]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_acos')
return CSRTensor(x.indptr, x.indices, math_func.acos(x.values), x.shape)
[docs]def coo_acos(x: COOTensor) -> COOTensor:
r"""
Computes arccosine of input coo_tensors element-wise.
.. math::
out_i = \cos^{-1}(x_i)
Args:
x (COOTensor): Input COOTensor.
Returns:
COOTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16, float32 or float64.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_acos(x)
>>> print(output.values)
[3.1415927 nan]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_acos')
return COOTensor(x.indices, math_func.acos(x.values), x.shape)
[docs]def csr_floor(x: CSRTensor) -> CSRTensor:
r"""
Rounds a CSRTensor down to the closest integer element-wise.
.. math::
out_i = \lfloor x_i \rfloor
Args:
x (CSRTensor): The input CSRTensor, its data type must be float16, float32 or float64.
Returns:
CSRTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not in [float16, float32, float64].
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_floor(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_floor')
return CSRTensor(x.indptr, x.indices, math_func.floor(x.values), x.shape)
[docs]def coo_floor(x: COOTensor) -> COOTensor:
r"""
Rounds a COOTensor down to the closest integer element-wise.
.. math::
out_i = \lfloor x_i \rfloor
Args:
x (COOTensor): The input COOTensor, its data type must be float16, float32 or float64.
Returns:
COOTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not in [float16, float32, float64].
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_floor(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_floor')
return COOTensor(x.indices, math_func.floor(x.values), x.shape)
[docs]def csr_atan(x: CSRTensor) -> CSRTensor:
r"""
Computes the trigonometric inverse tangent of the input element-wise.
.. math::
out_i = \tan^{-1}(x_i)
Args:
x (CSRTensor): The data type should be one of the following types: float16, float32.
Returns:
A CSRTensor, has the same type as the input.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_atan(x)
>>> print(output.values)
[-0.7853982 1.1071488]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_atan')
return CSRTensor(x.indptr, x.indices, math_func.atan(x.values), x.shape)
[docs]def coo_atan(x: COOTensor) -> COOTensor:
r"""
Computes the trigonometric inverse tangent of the input element-wise.
.. math::
out_i = \tan^{-1}(x_i)
Args:
x (COOTensor): The data type should be one of the following types: float16, float32.
Returns:
A COOTensor, has the same type as the input.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_atan(x)
>>> print(output.values)
[-0.7853982 1.1071488]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_atan')
return COOTensor(x.indices, math_func.atan(x.values), x.shape)
[docs]def csr_square(x: CSRTensor) -> CSRTensor:
"""
Returns square of a CSRTensor element-wise.
.. math::
out_{i} = (x_{i})^2
Args:
x (CSRTensor): The input CSRTensor with a dtype of Number.
Returns:
CSRTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_square(x)
>>> print(output.values)
[1. 4.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_square')
return CSRTensor(x.indptr, x.indices, math_func.square(x.values), x.shape)
[docs]def coo_square(x: COOTensor) -> COOTensor:
"""
Returns square of a COOTensor element-wise.
.. math::
out_{i} = (x_{i})^2
Args:
x (COOTensor): The input COOTensor with a dtype of Number.
Returns:
COOTensor, has the same shape and dtype as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_square(x)
>>> print(output.values)
[1. 4.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_square')
return COOTensor(x.indices, math_func.square(x.values), x.shape)
[docs]def csr_relu6(x: CSRTensor) -> CSRTensor:
r"""
Computes ReLU (Rectified Linear Unit) upper bounded by 6 of input csr_tensors element-wise.
.. math::
\text{ReLU6}(x) = \min(\max(0,x), 6)
It returns :math:`\min(\max(0,x), 6)` element-wise.
Args:
x (CSRTensor): Input CSRTensor, with float16 or float32 data type.
Returns:
CSRTensor, with the same dtype and shape as the `x`.
Raises:
TypeError: If dtype of `x` is neither float16 nor float32.
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_relu6(x)
>>> print(output.values)
[0. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_relu6')
return CSRTensor(x.indptr, x.indices, nn_func.relu6(x.values), x.shape)
[docs]def coo_relu6(x: COOTensor) -> COOTensor:
r"""
Computes ReLU (Rectified Linear Unit) upper bounded by 6 of input coo_tensors element-wise.
.. math::
\text{ReLU6}(x) = \min(\max(0,x), 6)
It returns :math:`\min(\max(0,x), 6)` element-wise.
Args:
x (COOTensor): Input COOTensor, with float16 or float32 data type.
Returns:
COOTensor, with the same dtype and shape as the `x`.
Raises:
TypeError: If dtype of `x` is neither float16 nor float32.
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_relu6(x)
>>> print(output.values)
[0. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_relu6')
return COOTensor(x.indices, nn_func.relu6(x.values), x.shape)
[docs]def csr_sinh(x: CSRTensor) -> CSRTensor:
r"""
Computes hyperbolic sine of the input element-wise.
.. math::
out_i = \sinh(x_i)
Args:
x (CSRTensor): The input CSRTensor of hyperbolic sine function.
Returns:
CSRTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_sinh(x)
>>> print(output.values)
[-1.1752012 3.6268604]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_sinh')
return CSRTensor(x.indptr, x.indices, math_func.sinh(x.values), x.shape)
[docs]def coo_sinh(x: COOTensor) -> COOTensor:
r"""
Computes hyperbolic sine of the input element-wise.
.. math::
out_i = \sinh(x_i)
Args:
x (COOTensor): The input COOTensor of hyperbolic sine function.
Returns:
COOTensor, has the same shape as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_sinh(x)
>>> print(output.values)
[-1.1752012 3.6268604]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_sinh')
return COOTensor(x.indices, math_func.sinh(x.values), x.shape)
[docs]def csr_ceil(x: CSRTensor) -> CSRTensor:
r"""
Rounds a CSRTensor up to the closest integer element-wise.
.. math::
out_i = \lceil x_i \rceil = \lfloor x_i \rfloor + 1
Args:
x (CSRTensor): The input CSRTensor with a dtype of float16 or float32.
Returns:
CSRTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_ceil(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_ceil')
return CSRTensor(x.indptr, x.indices, math_func.ceil(x.values), x.shape)
[docs]def coo_ceil(x: COOTensor) -> COOTensor:
r"""
Rounds a COOTensor up to the closest integer element-wise.
.. math::
out_i = \lceil x_i \rceil = \lfloor x_i \rfloor + 1
Args:
x (COOTensor): The input COOTensor with a dtype of float16 or float32.
Returns:
COOTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_ceil(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_ceil')
return COOTensor(x.indices, math_func.ceil(x.values), x.shape)
[docs]def csr_cosh(x: CSRTensor) -> CSRTensor:
r"""
Computes hyperbolic cosine of input element-wise.
.. math::
out_i = \cosh(x_i)
Args:
x (CSRTensor): The input CSRTensor of hyperbolic cosine function, its data type
must be float16, float32, float64, complex64 or complex128.
Returns:
CSRTensor, 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 CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_cosh(x)
>>> print(output.values)
[1.5430807 3.7621956]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_cosh')
return CSRTensor(x.indptr, x.indices, math_func.cosh(x.values), x.shape)
[docs]def coo_cosh(x: COOTensor) -> COOTensor:
r"""
Computes hyperbolic cosine of input element-wise.
.. math::
out_i = \cosh(x_i)
Args:
x (COOTensor): The input COOTensor of hyperbolic cosine function, its data type
must be float16, float32, float64, complex64 or complex128.
Returns:
COOTensor, 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 COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_cosh(x)
>>> print(output.values)
[1.5430807 3.7621956]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_cosh')
return COOTensor(x.indices, math_func.cosh(x.values), x.shape)
[docs]def csr_softsign(x: CSRTensor) -> CSRTensor:
r"""
Softsign activation function.
The function is shown as follows:
.. math::
\text{SoftSign}(x) = \frac{x}{1 + |x|}
Args:
x (CSRTensor): Input CSRTensor, with float16 or float32 data type.
Returns:
CSRTensor, with the same type and shape as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_softsign(x)
>>> print(output.values)
[-0.5 0.6666667]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_softsign')
return CSRTensor(x.indptr, x.indices, nn_func.softsign(x.values), x.shape)
[docs]def coo_softsign(x: COOTensor) -> COOTensor:
r"""
Softsign activation function.
The function is shown as follows:
.. math::
\text{SoftSign}(x) = \frac{x}{1 + |x|}
Args:
x (COOTensor): Input COOTensor, with float16 or float32 data type.
Returns:
COOTensor, with the same type and shape as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_softsign(x)
>>> print(output.values)
[-0.5 0.6666667]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_softsign')
return COOTensor(x.indices, nn_func.softsign(x.values), x.shape)
[docs]def csr_log1p(x: CSRTensor) -> CSRTensor:
r"""
Returns the natural logarithm of one plus the input CSRTensor element-wise.
.. math::
out_i = \text{log_e}(x_i + 1)
Args:
x (CSRTensor): The input CSRTensor. With float16 or float32 data type.
The value must be greater than -1.
Returns:
CSRTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_log1p(x)
>>> print(output.values)
[ -inf 1.0986123]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_log1p')
return CSRTensor(x.indptr, x.indices, math_func.log1p(x.values), x.shape)
[docs]def coo_log1p(x: COOTensor) -> COOTensor:
r"""
Returns the natural logarithm of one plus the input COOTensor element-wise.
.. math::
out_i = \text{log_e}(x_i + 1)
Args:
x (COOTensor): The input COOTensor, should have dtype of float16 or float32
and its value should be greater than -1.
Returns:
COOTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is neither float16 nor float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_log1p(x)
>>> print(output.values)
[ -inf 1.0986123]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_log1p')
return COOTensor(x.indices, math_func.log1p(x.values), x.shape)
[docs]def csr_round(x: CSRTensor) -> CSRTensor:
"""
Returns half to even of a CSRTensor element-wise.
.. math::
out_i \\approx x_i
Args:
x (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape and type as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_round(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_round')
return CSRTensor(x.indptr, x.indices, math_func.round(x.values), x.shape)
[docs]def coo_round(x: COOTensor) -> COOTensor:
r"""
Returns half to even of a COOTensor element-wise.
.. math::
out_i \approx x_i
Args:
x (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape and type as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_round(x)
>>> print(output.values)
[-1. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_round')
return COOTensor(x.indices, math_func.round(x.values), x.shape)
[docs]def csr_tanh(x: CSRTensor) -> CSRTensor:
r"""
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 CSRTensor.
Args:
x (CSRTensor): Input CSRTensor, with float16 or float32 data type.
Returns:
CSRTensor, with the same type and shape as the `x`.
Raises:
TypeError: If dtype of `x` is neither float16 nor float32.
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_tanh(x)
>>> print(output.values)
[-0.7615942 0.9640276]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_tanh')
return CSRTensor(x.indptr, x.indices, math_func.tanh(x.values), x.shape)
[docs]def coo_tanh(x: COOTensor) -> COOTensor:
r"""
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 COOTensor.
Args:
x (COOTensor): Input COOTensor, with float16 or float32 data type.
Returns:
COOTensor, with the same type and shape as the `x`.
Raises:
TypeError: If dtype of `x` is neither float16 nor float32.
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_tanh(x)
>>> print(output.values)
[-0.7615942 0.9640276]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_tanh')
return COOTensor(x.indices, math_func.tanh(x.values), x.shape)
[docs]def csr_asinh(x: CSRTensor) -> CSRTensor:
r"""
Computes inverse hyperbolic sine of the input element-wise.
.. math::
out_i = \sinh^{-1}(input_i)
Args:
x (CSRTensor): The input CSRTensor of inverse hyperbolic sine function, i.e. :math:`input_i`.
Returns:
CSRTensor, has the same shape and type as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_asinh(x)
>>> print(output.values)
[-0.8813736 1.4436355]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_asinh')
return CSRTensor(x.indptr, x.indices, math_func.asinh(x.values), x.shape)
[docs]def coo_asinh(x: COOTensor) -> COOTensor:
r"""
Computes inverse hyperbolic sine of the input element-wise.
.. math::
out_i = \sinh^{-1}(input_i)
Args:
x (COOTensor): The input COOTensor of inverse hyperbolic sine function.
Returns:
COOTensor, has the same shape and type as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_asinh(x)
>>> print(output.values)
[-0.8813736 1.4436355]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_asinh')
return COOTensor(x.indices, math_func.asinh(x.values), x.shape)
[docs]def csr_neg(x: CSRTensor) -> CSRTensor:
"""
Returns a CSRTensor with csr_negative values of the input CSRTensor element-wise.
.. math::
out_{i} = - x_{i}
Args:
x (CSRTensor): The input CSRTensor with a dtype of Number.
Returns:
CSRTensor, has the same shape and dtype as input.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_neg(x)
>>> print(output.values)
[ 1. -2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_neg')
return CSRTensor(x.indptr, x.indices, math_func.neg(x.values), x.shape)
[docs]def coo_neg(x: COOTensor) -> COOTensor:
"""
Returns a COOTensor with coo_negative values of the input COOTensor element-wise.
.. math::
out_{i} = - x_{i}
Args:
x (COOTensor): The input COOTensor with a dtype of Number.
Returns:
COOTensor, has the same shape and dtype as input.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_neg(x)
>>> print(output.values)
[ 1. -2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_neg')
return COOTensor(x.indices, math_func.neg(x.values), x.shape)
[docs]def csr_acosh(x: CSRTensor) -> CSRTensor:
r"""
Computes inverse hyperbolic cosine of the inputs element-wise.
.. math::
out_i = \cosh^{-1}(input_i)
Args:
x (CSRTensor): The input CSRTensor of inverse hyperbolic cosine function, i.e. :math:`input_i`,
its element must be in range [1, inf].
Returns:
CSRTensor, has the same shape and type as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_acosh(x)
>>> print(output.values)
[ nan 1.316958]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_acosh')
return CSRTensor(x.indptr, x.indices, math_func.acosh(x.values), x.shape)
[docs]def coo_acosh(x: COOTensor) -> COOTensor:
r"""
Computes inverse hyperbolic cosine of the inputs element-wise.
.. math::
y_i = \cosh^{-1}(x_i)
.. warning::
Given an input COOTensor x, the function computes inverse hyperbolic cosine of every element.
Input range is [1, inf].
Args:
x (COOTensor): The input COOTensor of inverse hyperbolic cosine function.
Returns:
COOTensor, has the same shape and type as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_acosh(x)
>>> print(output.values)
[ nan 1.316958]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_acosh')
return COOTensor(x.indices, math_func.acosh(x.values), x.shape)
[docs]def csr_isinf(x: CSRTensor) -> CSRTensor:
r"""
Determines which elements are inf or -inf for each position.
.. math::
out_i = \begin{cases}
& \text{ if } x_{i} = \text{Inf},\ \ True \\
& \text{ if } x_{i} \ne \text{Inf},\ \ False
\end{cases}
where :math:`Inf` means not a number.
Args:
x (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_isinf(x)
>>> print(output.values)
[False False]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_isinf')
return CSRTensor(x.indptr, x.indices, math_func.isinf(x.values), x.shape)
[docs]def coo_isinf(x: COOTensor) -> COOTensor:
r"""
Determines which elements are inf or -inf for each position.
.. math::
out_i = \begin{cases}
& \text{ if } x_{i} = \text{Inf},\ \ True \\
& \text{ if } x_{i} \ne \text{Inf},\ \ False
\end{cases}
where :math:`Inf` means infinitity or negative infinitity.
Args:
x (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape of input, and the dtype is bool.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_isinf(x)
>>> print(output.values)
[False False]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_isinf')
return COOTensor(x.indices, math_func.isinf(x.values), x.shape)
[docs]def csr_atanh(x: CSRTensor) -> CSRTensor:
r"""
Computes inverse hyperbolic tangent of the input element-wise.
.. math::
out_i = \tanh^{-1}(x_{i})
.. warning::
This is an experimental API that is subject to change or deletion.
Args:
x (CSRTensor): Input CSRTensor. The shape 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 CSRTensor, has the same type as the input.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_atanh(x)
>>> print(output.values)
[-inf nan]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_atanh')
return CSRTensor(x.indptr, x.indices, math_func.atanh(x.values), x.shape)
[docs]def coo_atanh(x: COOTensor) -> COOTensor:
r"""
Computes inverse hyperbolic tangent of the input element-wise.
.. math::
out_i = \tanh^{-1}(x_{i})
.. warning::
This is an experimental API that is subject to change or deletion.
Args:
x (COOTensor): Input COOTensor.
The data type should be one of the following types: float16, float32.
Returns:
A COOTensor, has the same type as the input.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16 or float32.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_atanh(x)
>>> print(output.values)
[-inf nan]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_atanh')
return COOTensor(x.indices, math_func.atanh(x.values), x.shape)
[docs]def csr_sigmoid(x: CSRTensor) -> CSRTensor:
r"""
Sigmoid activation function.
Computes Sigmoid of input element-wise. The Sigmoid function is defined as:
.. math::
\text{csr_sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)}
where :math:`x_i` is an element of the x.
Args:
x (CSRTensor): Input CSRTensor, the data type is float16, float32, float64, complex64 or complex128.
Returns:
CSRTensor, with the same type and shape as the x.
Raises:
TypeError: If dtype of `x` is not float16, float32, float64, complex64 or complex128.
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_sigmoid(x)
>>> print(output.values)
[0.26894143 0.8807971 ]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_sigmoid')
return CSRTensor(x.indptr, x.indices, nn_func.sigmoid(x.values), x.shape)
[docs]def coo_sigmoid(x: COOTensor) -> COOTensor:
r"""
Sigmoid activation function.
Computes Sigmoid of input element-wise. The Sigmoid function is defined as:
.. math::
\text{coo_sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)}
where :math:`x_i` is an element of the x.
Args:
x (COOTensor): Input COOTensor, the data type is float16, float32, float64, complex64 or complex128.
Returns:
COOTensor, with the same type and shape as the x.
Raises:
TypeError: If dtype of `x` is not float16, float32, float64, complex64 or complex128.
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_sigmoid(x)
>>> print(output.values)
[0.26894143 0.8807971 ]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_sigmoid')
return COOTensor(x.indices, nn_func.sigmoid(x.values), x.shape)
[docs]def csr_abs(x: CSRTensor) -> CSRTensor:
"""
Returns csr_absolute value of a CSRTensor element-wise.
.. math::
out_i = |x_i|
Args:
x (CSRTensor): The input CSRTensor.
Returns:
CSRTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_abs(x)
>>> print(output.values)
[1. 2.]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_abs')
return CSRTensor(x.indptr, x.indices, math_func.abs(x.values), x.shape)
[docs]def coo_abs(x: COOTensor) -> COOTensor:
"""
Returns coo_absolute value of a COOTensor element-wise.
.. math::
out_i = |x_i|
Args:
x (COOTensor): The input COOTensor.
Returns:
COOTensor, has the same shape as the `x`.
Raises:
TypeError: If `x` is not a COOTensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_abs(x)
>>> print(output.values)
[1. 2.]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_abs')
return COOTensor(x.indices, math_func.abs(x.values), x.shape)
[docs]def csr_sin(x: CSRTensor) -> CSRTensor:
r"""
Computes sine of the input element-wise.
.. math::
out_i = \sin(x_i)
Args:
x (CSRTensor): Input CSRTensor.
Returns:
CSRTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a CSRTensor.
TypeError: If dtype of `x` is not float16, float32 or float64, complex64,
complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, CSRTensor
>>> indptr = Tensor([0, 1, 2, 2], dtype=mstype.int32)
>>> indices = Tensor([3, 0], dtype=mstype.int32)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = CSRTensor(indptr, indices, values, shape)
>>> output = ops.csr_sin(x)
>>> print(output.values)
[-0.84147096 0.9092974 ]
"""
if not isinstance(x, CSRTensor):
raise_type_error('Expects CSRTensor for csr_sin')
return CSRTensor(x.indptr, x.indices, math_func.sin(x.values), x.shape)
[docs]def coo_sin(x: COOTensor) -> COOTensor:
r"""
Computes sine of the input element-wise.
.. math::
out_i = \sin(x_i)
Args:
x (COOTensor): Input COOTensor.
Returns:
COOTensor, has the same shape and dtype as `x`.
Raises:
TypeError: If `x` is not a COOTensor.
TypeError: If dtype of `x` is not float16, float32 or float64, complex64,
complex128.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> from mindspore import dtype as mstype
>>> from mindspore import Tensor, ops, COOTensor
>>> indices = Tensor([[0, 1], [1, 2]], dtype=mstype.int64)
>>> values = Tensor([-1, 2], dtype=mstype.float32)
>>> shape = (3, 4)
>>> x = COOTensor(indices, values, shape)
>>> output = ops.coo_sin(x)
>>> print(output.values)
[-0.84147096 0.9092974 ]
"""
if not isinstance(x, COOTensor):
raise_type_error('Expects COOTensor for coo_sin')
return COOTensor(x.indices, math_func.sin(x.values), x.shape)
__all__ = [
"csr_cos", "csr_tan", "csr_exp", "csr_inv", "csr_relu", "csr_expm1", "csr_isfinite",
"csr_asin", "csr_sqrt", "csr_log", "csr_isnan", "csr_acos", "csr_floor", "csr_atan",
"csr_square", "csr_relu6", "csr_sinh", "csr_ceil", "csr_cosh", "csr_softsign",
"csr_log1p", "csr_round", "csr_tanh", "csr_asinh", "csr_neg", "csr_acosh", "csr_isinf",
"csr_atanh", "csr_sigmoid", "csr_abs", "csr_sin", "coo_cos", "coo_tan", "coo_exp",
"coo_inv", "coo_relu", "coo_expm1", "coo_isfinite", "coo_asin", "coo_sqrt", "coo_log",
"coo_isnan", "coo_acos", "coo_floor", "coo_atan", "coo_square", "coo_relu6", "coo_sinh",
"coo_ceil", "coo_cosh", "coo_softsign", "coo_log1p", "coo_round", "coo_tanh",
"coo_asinh", "coo_neg", "coo_acosh", "coo_isinf", "coo_atanh", "coo_sigmoid", "coo_abs",
"coo_sin"
]
__all__.sort()