maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/isclose.py

@@ -0,0 +1,114 @@
+# Copyright 1999-2025 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 ...serialization.serializables import BoolField, Float64Field
+from .core import TensorBinOp
+
+
+class TensorIsclose(TensorBinOp):
+    _op_type_ = opcodes.ISCLOSE
+    _func_name = "isclose"
+
+    rtol = Float64Field("rtol", default=None)
+    atol = Float64Field("atol", default=None)
+    equal_nan = BoolField("equal_nan", default=None)
+
+    def __init__(self, casting="same_kind", err=None, sparse=False, **kw):
+        err = err if err is not None else np.geterr()
+        super().__init__(casting=casting, err=err, sparse=sparse, **kw)
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if (
+            hasattr(x1, "issparse")
+            and x1.issparse()
+            and np.isscalar(x2)
+            and not np.isclose(x2, 0)
+        ):
+            return True
+        if (
+            hasattr(x2, "issparse")
+            and x2.issparse()
+            and np.isscalar(x1)
+            and not np.isclose(x1, 0)
+        ):
+            return True
+        return False
+
+
+def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
+    """
+    Returns a boolean tensor where two tensors are element-wise equal within a
+    tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input tensors to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output tensor.
+
+    Returns
+    -------
+    y : array_like
+        Returns a boolean tensor of where `a` and `b` are equal within the
+        given tolerance. If both `a` and `b` are scalars, returns a single
+        boolean value.
+
+    See Also
+    --------
+    allclose
+
+    Notes
+    -----
+
+    For finite values, isclose uses the following equation to test whether
+    two floating point values are equivalent.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    The above equation is not symmetric in `a` and `b`, so that
+    `isclose(a, b)` might be different from `isclose(b, a)` in
+    some rare cases.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.isclose([1e10,1e-7], [1.00001e10,1e-8]).execute()
+    array([True, False])
+    >>> mt.isclose([1e10,1e-8], [1.00001e10,1e-9]).execute()
+    array([True, True])
+    >>> mt.isclose([1e10,1e-8], [1.0001e10,1e-9]).execute()
+    array([False, True])
+    >>> mt.isclose([1.0, mt.nan], [1.0, mt.nan]).execute()
+    array([True, False])
+    >>> mt.isclose([1.0, mt.nan], [1.0, mt.nan], equal_nan=True).execute()
+    array([True, True])
+    """
+    op = TensorIsclose(rtol=rtol, atol=atol, equal_nan=equal_nan, dtype=np.dtype(bool))
+    return op(a, b)

maxframe/tensor/arithmetic/iscomplex.py

@@ -0,0 +1,62 @@
+# Copyright 1999-2025 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/iscomplexobj.py

@@ -0,0 +1,53 @@
+# Copyright 1999-2025 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
+
+
+def iscomplexobj(x):
+    """
+    Check for a complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. Even if the input
+    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    iscomplexobj : bool
+        The return value, True if `x` is of a complex type or has at least
+        one complex element.
+
+    See Also
+    --------
+    isrealobj, iscomplex
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> mt.iscomplexobj(1)
+    False
+    >>> mt.iscomplexobj(1+0j)
+    True
+    >>> mt.iscomplexobj([3, 1+0j, True])
+    True
+    """
+    from ..datasource.array import tensor as astensor
+
+    t = astensor(x)
+    return issubclass(t.dtype.type, np.complexfloating)

maxframe/tensor/arithmetic/isfinite.py

@@ -0,0 +1,104 @@
+# Copyright 1999-2025 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="always_false")
+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,101 @@
+# Copyright 1999-2025 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,80 @@
+# Copyright 1999-2025 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,61 @@
+# Copyright 1999-2025 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,97 @@
+# Copyright 1999-2025 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)