maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/mod.py

@@ -0,0 +1,102 @@
+# 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 infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_or")
+class TensorMod(TensorBinOp):
+    _op_type_ = opcodes.MOD
+    _func_name = "mod"
+
+
+@infer_dtype(np.mod)
+def mod(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return element-wise remainder of division.
+
+    Computes the remainder complementary to the `floor_divide` function.  It is
+    equivalent to the Python modulus operator``x1 % x2`` and has the same sign
+    as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
+    is ``mod``.
+
+    .. warning::
+
+        This should not be confused with:
+
+        * Python 3.7's `math.remainder` and C's ``remainder``, which
+          computes the IEEE remainder, which are the complement to
+          ``round(x1 / x2)``.
+        * The MATLAB ``rem`` function and or the C ``%`` operator which is the
+          complement to ``int(x1 / x2)``.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Dividend array.
+    x2 : array_like
+        Divisor array.
+    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
+        The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
+        Returns a scalar if both  `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    floor_divide : Equivalent of Python ``//`` operator.
+    divmod : Simultaneous floor division and remainder.
+    fmod : Equivalent of the MATLAB ``rem`` function.
+    divide, floor
+
+    Notes
+    -----
+    Returns 0 when `x2` is 0 and both `x1` and `x2` are (tensors of)
+    integers.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.remainder([4, 7], [2, 3]).execute()
+    array([0, 1])
+    >>> mt.remainder(mt.arange(7), 5).execute()
+    array([0, 1, 2, 3, 4, 0, 1])
+    """
+    op = TensorMod(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+remainder = mod
+
+
+@infer_dtype(np.mod, reverse=True)
+def rmod(x1, x2, **kwargs):
+    op = TensorMod(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/modf.py

@@ -0,0 +1,87 @@
+# 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 .core import TensorOutBinOp
+
+
+class TensorModf(TensorOutBinOp):
+    _op_type_ = opcodes.MODF
+
+    def __init__(self, casting="same_kind", dtype=None, sparse=False, **kw):
+        super().__init__(casting=casting, dtype=dtype, sparse=sparse, **kw)
+
+    @property
+    def _fun(self):
+        return np.modf
+
+    @classmethod
+    def _is_sparse(cls, x):
+        if hasattr(x, "issparse") and x.issparse():
+            return True
+        return False
+
+
+def modf(x, out1=None, out2=None, out=None, where=None, **kwargs):
+    """
+    Return the fractional and integral parts of a tensor, element-wise.
+
+    The fractional and integral parts are negative if the given number is
+    negative.
+
+    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
+    -------
+    y1 : Tensor
+        Fractional part of `x`.
+    y2 : Tensor
+        Integral part of `x`.
+
+    Notes
+    -----
+    For integer input the return values are floats.
+
+    See Also
+    --------
+    divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
+             switched, except it always has a positive remainder.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.modf([0, 3.5]).execute()
+    (array([ 0. ,  0.5]), array([ 0.,  3.]))
+    >>> mt.modf(-0.5).execute()
+    (-0.5, -0)
+    """
+    x = astensor(x)
+    op = TensorModf(**kwargs)
+    return op(x, out1=out1, out2=out2, out=out, where=where)

maxframe/tensor/arithmetic/multiply.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 functools
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import BoolField
+from ..datasource import scalar
+from ..utils import infer_dtype
+from .core import TensorBinOp, TensorMultiOp
+from .utils import TreeReductionBuilder, arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_or")
+class TensorMultiply(TensorBinOp):
+    _op_type_ = opcodes.MUL
+    _func_name = "multiply"
+
+
+@infer_dtype(np.multiply)
+def multiply(x1, x2, out=None, where=None, **kwargs):
+    """
+    Multiply arguments element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Input arrays to be multiplied.
+    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
+        The product of `x1` and `x2`, element-wise. Returns a scalar if
+        both  `x1` and `x2` are scalars.
+
+    Notes
+    -----
+    Equivalent to `x1` * `x2` in terms of array broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.multiply(2.0, 4.0).execute()
+    8.0
+
+    >>> x1 = mt.arange(9.0).reshape((3, 3))
+    >>> x2 = mt.arange(3.0)
+    >>> mt.multiply(x1, x2).execute()
+    array([[  0.,   1.,   4.],
+           [  0.,   4.,  10.],
+           [  0.,   7.,  16.]])
+    """
+    op = TensorMultiply(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.multiply, reverse=True)
+def rmultiply(x1, x2, **kwargs):
+    op = TensorMultiply(**kwargs)
+    return op.rcall(x1, x2)
+
+
+class TensorTreeMultiply(TensorMultiOp):
+    _op_type_ = opcodes.TREE_MULTIPLY
+    _func_name = "multiply"
+
+    ignore_empty_input = BoolField("ignore_empty_input", default=False)
+
+    def __init__(self, sparse=False, **kw):
+        super().__init__(sparse=sparse, **kw)
+
+    @classmethod
+    def _is_sparse(cls, *args):
+        if not args or all(np.isscalar(x) for x in args):
+            return False
+        if all(
+            np.isscalar(x) or (hasattr(x, "issparse") and x.issparse()) for x in args
+        ):
+            return True
+        return False
+
+
+@infer_dtype(lambda *args: functools.reduce(np.multiply, args))
+def tree_multiply(*args, combine_size=None, **kwargs):
+    class MultiplyBuilder(TreeReductionBuilder):
+        def _build_reduction(self, inputs, final=False):
+            op = TensorTreeMultiply(args=inputs, **kwargs)
+            return op(*inputs)
+
+    args = [scalar(a) if np.isscalar(a) else a for a in args]
+    return MultiplyBuilder(combine_size).build(args)

maxframe/tensor/arithmetic/nan_to_num.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 ..core import Tensor
+from ..utils import infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorNanToNum(TensorUnaryOp):
+    _op_type_ = opcodes.NAN_TO_NUM
+    _func_name = "nan_to_num"
+
+
+@infer_dtype(np.nan_to_num)
+def nan_to_num(x, copy=True, **kwargs):
+    """
+    Replace nan with zero and inf with large finite numbers.
+
+    If `x` is inexact, NaN is replaced by zero, and infinity and -infinity
+    replaced by the respectively largest and most negative finite floating
+    point values representable by ``x.dtype``.
+
+    For complex dtypes, the above is applied to each of the real and
+    imaginary components of `x` separately.
+
+    If `x` is not inexact, then no replacements are made.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data.
+    copy : bool, optional
+        Whether to create a copy of `x` (True) or to replace values
+        in-place (False). The in-place operation only occurs if
+        casting to an array does not require a copy.
+        Default is True.
+
+    Returns
+    -------
+    out : Tensor
+        `x`, with the non-finite values replaced. If `copy` is False, this may
+        be `x` itself.
+
+    See Also
+    --------
+    isinf : Shows which elements are positive or negative infinity.
+    isneginf : Shows which elements are negative infinity.
+    isposinf : Shows which elements are positive infinity.
+    isnan : Shows which elements are Not a Number (NaN).
+    isfinite : Shows which elements are finite (not NaN, not infinity)
+
+    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
+
+    >>> x = mt.array([mt.inf, -mt.inf, mt.nan, -128, 128])
+    >>> mt.nan_to_num(x).execute()
+    array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000,
+            -1.28000000e+002,   1.28000000e+002])
+    >>> y = mt.array([complex(mt.inf, mt.nan), mt.nan, complex(mt.nan, mt.inf)])
+    >>> mt.nan_to_num(y).execute()
+    array([  1.79769313e+308 +0.00000000e+000j,
+             0.00000000e+000 +0.00000000e+000j,
+             0.00000000e+000 +1.79769313e+308j])
+    """
+    op = TensorNanToNum(**kwargs)
+    ret = op(x)
+
+    if copy:
+        return ret
+
+    # set back, make sure x is a Tensor
+    if not isinstance(x, Tensor):
+        raise ValueError(f"`x` must be a Tensor, got {type(x)} instead")
+    x.data = ret.data
+    return x

maxframe/tensor/arithmetic/negative.py

@@ -0,0 +1,63 @@
+# 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 infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorNegative(TensorUnaryOp):
+    _op_type_ = opcodes.NEGATIVE
+    _func_name = "negative"
+
+
+@infer_dtype(np.negative)
+def negative(x, out=None, where=None, **kwargs):
+    """
+    Numerical negative, element-wise.
+
+    Parameters
+    ----------
+    x : array_like or scalar
+        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
+        For other keyword-only arguments, see the
+        :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    Returns
+    -------
+    y : Tensor or scalar
+        Returned array or scalar: `y = -x`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.negative([1.,-1.]).execute()
+    array([-1.,  1.])
+    """
+    op = TensorNegative(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/nextafter.py

@@ -0,0 +1,66 @@
+# 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 infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorNextafter(TensorBinOp):
+    _op_type_ = opcodes.NEXTAFTER
+    _func_name = "nextafter"
+
+
+@infer_dtype(np.nextafter)
+def nextafter(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return the next floating-point value after x1 towards x2, element-wise.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Values to find the next representable value of.
+    x2 : array_like
+        The direction where to look for the next representable value of `x1`.
+    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 : array_like
+        The next representable values of `x1` in the direction of `x2`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> eps = mt.finfo(mt.float64).eps
+    >>> (mt.nextafter(1, 2) == eps + 1).execute()
+    True
+    >>> (mt.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]).execute()
+    array([ True,  True])
+    """
+    op = TensorNextafter(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/not_equal.py

@@ -0,0 +1,70 @@
+# 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 TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorNotEqual(TensorBinOp):
+    _op_type_ = opcodes.NE
+    _func_name = "not_equal"
+
+
+@inject_dtype(np.bool_)
+def not_equal(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return (x1 != x2) element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+      Input tensors.
+    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
+    -------
+    not_equal : tensor bool, scalar bool
+      For each element in `x1, x2`, return True if `x1` is not equal
+      to `x2` and False otherwise.
+
+
+    See Also
+    --------
+    equal, greater, greater_equal, less, less_equal
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.not_equal([1.,2.], [1., 3.]).execute()
+    array([False,  True])
+    >>> mt.not_equal([1, 2], [[1, 3],[1, 4]]).execute()
+    array([[False,  True],
+           [False,  True]])
+    """
+    op = TensorNotEqual(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/positive.py

@@ -0,0 +1,45 @@
+# 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 infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorPositive(TensorUnaryOp):
+    _op_type_ = opcodes.POSITIVE
+    _func_name = "positive"
+
+
+@infer_dtype(np.positive)
+def positive(x, out=None, where=None, **kwargs):
+    """
+    Numerical positive, element-wise.
+
+    Parameters
+    ----------
+    x : array_like or scalar
+        Input tensor.
+
+    Returns
+    -------
+    y : Tensor or scalar
+        Returned array or scalar: `y = +x`.
+    """
+    op = TensorPositive(**kwargs)
+    return op(x, out=out, where=where)