maxframe 0.1.0b5__cp310-cp310-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/iscomplex.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorIsComplex(TensorUnaryOp):
+    _op_type_ = opcodes.ISCOMPLEX
+    _func_name = "iscomplex"
+
+
+@inject_dtype(np.bool_)
+def iscomplex(x, **kwargs):
+    """
+    Returns a bool tensor, where True if input element is complex.
+
+    What is tested is whether the input has a non-zero imaginary part, not if
+    the input type is complex.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+
+    Returns
+    -------
+    out : Tensor of bools
+        Output tensor.
+
+    See Also
+    --------
+    isreal
+    iscomplexobj : Return True if x is a complex type or an array of complex
+                   numbers.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]).execute()
+    array([ True, False, False, False, False,  True])
+
+    """
+    op = TensorIsComplex(**kwargs)
+    return op(x)

maxframe/tensor/arithmetic/isfinite.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorIsFinite(TensorUnaryOp):
+    _op_type_ = opcodes.ISFINITE
+    _func_name = "isfinite"
+
+
+@inject_dtype(np.bool_)
+def isfinite(x, out=None, where=None, **kwargs):
+    """
+    Test element-wise for finiteness (not infinity or not Not a Number).
+
+    The result is returned as a boolean tensor.
+
+    Parameters
+    ----------
+    x : array_like
+        Input values.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor, bool
+        For scalar input, the result is a new boolean with value True
+        if the input is finite; otherwise the value is False (input is
+        either positive infinity, negative infinity or Not a Number).
+
+        For array input, the result is a boolean array with the same
+        dimensions as the input and the values are True if the
+        corresponding element of the input is finite; otherwise the values
+        are False (element is either positive infinity, negative infinity
+        or Not a Number).
+
+    See Also
+    --------
+    isinf, isneginf, isposinf, isnan
+
+    Notes
+    -----
+    Not a Number, positive infinity and negative infinity are considered
+    to be non-finite.
+
+    MaxFrame uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Also that positive infinity is not equivalent to negative infinity. But
+    infinity is equivalent to positive infinity.  Errors result if the
+    second argument is also supplied when `x` is a scalar input, or if
+    first and second arguments have different shapes.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.isfinite(1).execute()
+    True
+    >>> mt.isfinite(0).execute()
+    True
+    >>> mt.isfinite(mt.nan).execute()
+    False
+    >>> mt.isfinite(mt.inf).execute()
+    False
+    >>> mt.isfinite(mt.NINF).execute()
+    False
+    >>> mt.isfinite([mt.log(-1.).execute(),1.,mt.log(0).execute()]).execute()
+    array([False,  True, False])
+
+    >>> x = mt.array([-mt.inf, 0., mt.inf])
+    >>> y = mt.array([2, 2, 2])
+    >>> mt.isfinite(x, y).execute()
+    array([0, 1, 0])
+    >>> y.execute()
+    array([0, 1, 0])
+    """
+    op = TensorIsFinite(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/isinf.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorIsInf(TensorUnaryOp):
+    _op_type_ = opcodes.ISINF
+    _func_name = "isinf"
+
+
+@inject_dtype(np.bool_)
+def isinf(x, out=None, where=None, **kwargs):
+    """
+    Test element-wise for positive or negative infinity.
+
+    Returns a boolean array of the same shape as `x`, True where ``x ==
+    +/-inf``, otherwise False.
+
+    Parameters
+    ----------
+    x : array_like
+        Input values
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : bool (scalar) or boolean Tensor
+        For scalar input, the result is a new boolean with value True if
+        the input is positive or negative infinity; otherwise the value is
+        False.
+
+        For tensor input, the result is a boolean tensor with the same shape
+        as the input and the values are True where the corresponding
+        element of the input is positive or negative infinity; elsewhere
+        the values are False.  If a second argument was supplied the result
+        is stored there.  If the type of that array is a numeric type the
+        result is represented as zeros and ones, if the type is boolean
+        then as False and True, respectively.  The return value `y` is then
+        a reference to that tensor.
+
+    See Also
+    --------
+    isneginf, isposinf, isnan, isfinite
+
+    Notes
+    -----
+    MaxFrame uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is supplied when the first
+    argument is a scalar, or if the first and second arguments have
+    different shapes.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.isinf(mt.inf).execute()
+    True
+    >>> mt.isinf(mt.nan).execute()
+    False
+    >>> mt.isinf(mt.NINF).execute()
+    True
+    >>> mt.isinf([mt.inf, -mt.inf, 1.0, mt.nan]).execute()
+    array([ True,  True, False, False])
+
+    >>> x = mt.array([-mt.inf, 0., mt.inf])
+    >>> y = mt.array([2, 2, 2])
+    >>> mt.isinf(x, y).execute()
+    array([1, 0, 1])
+    >>> y.execute()
+    array([1, 0, 1])
+    """
+    op = TensorIsInf(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/isnan.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorIsNan(TensorUnaryOp):
+    _op_type_ = opcodes.ISNAN
+    _func_name = "isnan"
+
+
+@inject_dtype(np.bool_)
+def isnan(x, out=None, where=None, **kwargs):
+    """
+    Test element-wise for NaN and return result as a boolean tensor.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor or bool
+        For scalar input, the result is a new boolean with value True if
+        the input is NaN; otherwise the value is False.
+
+        For array input, the result is a boolean tensor of the same
+        dimensions as the input and the values are True if the
+        corresponding element of the input is NaN; otherwise the values are
+        False.
+
+    See Also
+    --------
+    isinf, isneginf, isposinf, isfinite, isnat
+
+    Notes
+    -----
+    MaxFrame uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.isnan(mt.nan).execute()
+    True
+    >>> mt.isnan(mt.inf).execute()
+    False
+    >>> mt.isnan([mt.log(-1.).execute(),1.,mt.log(0).execute()]).execute()
+    array([ True, False, False])
+    """
+    op = TensorIsNan(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/isreal.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorIsReal(TensorUnaryOp):
+    _op_type_ = opcodes.ISREAL
+    _func_name = "isreal"
+
+
+@inject_dtype(np.bool_)
+def isreal(x, **kwargs):
+    """
+    Returns a bool tensor, where True if input element is real.
+
+    If element has complex type with zero complex part, the return value
+    for that element is True.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+
+    Returns
+    -------
+    out : Tensor, bool
+        Boolean tensor of same shape as `x`.
+
+    See Also
+    --------
+    iscomplex
+    isrealobj : Return True if x is not a complex type.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j]).execute()
+    array([False,  True,  True,  True,  True, False])
+
+    """
+    op = TensorIsReal(**kwargs)
+    return op(x)

maxframe/tensor/arithmetic/ldexp.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from ..utils import infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator
+class TensorLdexp(TensorBinOp):
+    _op_type_ = opcodes.LDEXP
+    _func_name = "ldexp"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            return True
+        return False
+
+
+@infer_dtype(np.ldexp)
+def ldexp(x1, x2, out=None, where=None, **kwargs):
+    """
+    Returns x1 * 2**x2, element-wise.
+
+    The mantissas `x1` and twos exponents `x2` are used to construct
+    floating point numbers ``x1 * 2**x2``.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Tensor of multipliers.
+    x2 : array_like, int
+        Tensor of twos exponents.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor or scalar
+        The result of ``x1 * 2**x2``.
+
+    See Also
+    --------
+    frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.
+
+    Notes
+    -----
+    Complex dtypes are not supported, they will raise a TypeError.
+
+    `ldexp` is useful as the inverse of `frexp`, if used by itself it is
+    more clear to simply use the expression ``x1 * 2**x2``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.ldexp(5, mt.arange(4)).execute()
+    array([  5.,  10.,  20.,  40.], dtype=float32)
+
+    >>> x = mt.arange(6)
+    >>> mt.ldexp(*mt.frexp(x)).execute()
+    array([ 0.,  1.,  2.,  3.,  4.,  5.])
+    """
+    x2_dtype = astensor(x2).dtype
+    casting = kwargs.get("casting", "safe")
+    if not np.can_cast(x2_dtype, np.int64, casting=casting):
+        raise TypeError(
+            "ufunc 'ldexp' not supported for the input types, "
+            "and the inputs could not be safely coerced to any supported types "
+            f"according to the casting rule ''{casting}''"
+        )
+
+    op = TensorLdexp(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/less.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorLessThan(TensorBinOp):
+    _op_type_ = opcodes.LT
+    _func_name = "less"
+
+
+@inject_dtype(np.bool_)
+def less(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return the truth value of (x1 < x2) element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Input tensors.  If ``x1.shape != x2.shape``, they must be
+        broadcastable to a common shape (which may be the shape of one or
+        the other).
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : bool or Tensor of bool
+        Array of bools, or a single bool if `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    greater, less_equal, greater_equal, equal, not_equal
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.less([1, 2], [2, 2]).execute()
+    array([ True, False])
+    """
+    op = TensorLessThan(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/less_equal.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 Alibaba Group Holding 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.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import inject_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorLessEqual(TensorBinOp):
+    _op_type_ = opcodes.LE
+    _func_name = "less_equal"
+
+
+@inject_dtype(np.bool_)
+def less_equal(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return the truth value of (x1 =< x2) element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Input tensors.  If ``x1.shape != x2.shape``, they must be
+        broadcastable to a common shape (which may be the shape of one or
+        the other).
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : bool or tensor of bool
+        Array of bools, or a single bool if `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    greater, less, greater_equal, equal, not_equal
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.less_equal([4, 2, 1], [2, 2, 2]).execute()
+    array([False,  True,  True])
+    """
+    op = TensorLessEqual(**kwargs)
+    return op(x1, x2, out=out, where=where)