maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/logical_and.py

@@ -0,0 +1,79 @@
+# 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 TensorAnd(TensorBinOp):
+    _op_type_ = opcodes.AND
+    _func_name = "logical_and"
+
+
+@infer_dtype(np.logical_and)
+def logical_and(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the truth value of x1 AND x2 element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Input tensors. `x1` and `x2` must be of the same shape.
+    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
+        Boolean result with the same shape as `x1` and `x2` of the logical
+        AND operation on corresponding elements of `x1` and `x2`.
+
+    See Also
+    --------
+    logical_or, logical_not, logical_xor
+    bitwise_and
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.logical_and(True, False).execute()
+    False
+    >>> mt.logical_and([True, False], [False, False]).execute()
+    array([False, False])
+
+    >>> x = mt.arange(5)
+    >>> mt.logical_and(x>1, x<4).execute()
+    array([False, False,  True,  True, False])
+    """
+    op = TensorAnd(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.logical_and, reverse=True)
+def rlogical_and(x1, x2, **kwargs):
+    op = TensorAnd(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/logical_not.py

@@ -0,0 +1,72 @@
+# 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="always_false")
+class TensorNot(TensorUnaryOp):
+    _op_type_ = opcodes.NOT
+    _func_name = "logical_not"
+
+
+@infer_dtype(np.logical_not)
+def logical_not(x, out=None, where=None, **kwargs):
+    """
+    Compute the truth value of NOT x element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        Logical NOT is applied to the elements of `x`.
+    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 or Tensor of bool
+        Boolean result with the same shape as `x` of the NOT operation
+        on elements of `x`.
+
+    See Also
+    --------
+    logical_and, logical_or, logical_xor
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.logical_not(3).execute()
+    False
+    >>> mt.logical_not([True, False, 0, 1]).execute()
+    array([False,  True,  True, False])
+
+    >>> x = mt.arange(5)
+    >>> mt.logical_not(x<3).execute()
+    array([False, False, False,  True,  True])
+    """
+    op = TensorNot(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/logical_or.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 infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorOr(TensorBinOp):
+    _op_type_ = opcodes.OR
+    _func_name = "logical_or"
+
+
+@infer_dtype(np.logical_or)
+def logical_or(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the truth value of x1 OR x2 element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Logical OR is applied to the elements of `x1` and `x2`.
+        They have to be of the same shape.
+    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
+        Boolean result with the same shape as `x1` and `x2` of the logical
+        OR operation on elements of `x1` and `x2`.
+
+    See Also
+    --------
+    logical_and, logical_not, logical_xor
+    bitwise_or
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.logical_or(True, False).execute()
+    True
+    >>> mt.logical_or([True, False], [False, False]).execute()
+    array([ True, False])
+
+    >>> x = mt.arange(5)
+    >>> mt.logical_or(x < 1, x > 3).execute()
+    array([ True, False, False, False,  True])
+    """
+    op = TensorOr(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.logical_or, reverse=True)
+def rlogical_or(x1, x2, **kwargs):
+    op = TensorOr(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/logical_xor.py

@@ -0,0 +1,86 @@
+# 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 TensorXor(TensorBinOp):
+    _op_type_ = opcodes.XOR
+    _func_name = "logical_xor"
+
+
+@infer_dtype(np.logical_xor)
+def logical_xor(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the truth value of x1 XOR x2, element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Logical XOR is applied to the elements of `x1` and `x2`.  They must
+        be broadcastable to the same shape.
+    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 or Tensor of bool
+        Boolean result of the logical XOR operation applied to the elements
+        of `x1` and `x2`; the shape is determined by whether or not
+        broadcasting of one or both arrays was required.
+
+    See Also
+    --------
+    logical_and, logical_or, logical_not, bitwise_xor
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.logical_xor(True, False).execute()
+    True
+    >>> mt.logical_xor([True, True, False, False], [True, False, True, False]).execute()
+    array([False,  True,  True, False])
+
+    >>> x = mt.arange(5)
+    >>> mt.logical_xor(x < 1, x > 3).execute()
+    array([ True, False, False, False,  True])
+
+    Simple example showing support of broadcasting
+
+    >>> mt.logical_xor(0, mt.eye(2)).execute()
+    array([[ True, False],
+           [False,  True]])
+    """
+    op = TensorXor(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.logical_xor, reverse=True)
+def rlogical_xor(x1, x2, **kwargs):
+    op = TensorXor(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/lshift.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 infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_or")
+class TensorLshift(TensorBinOp):
+    _op_type_ = opcodes.LSHIFT
+    _func_name = "left_shift"
+
+
+@infer_dtype(np.left_shift)
+def lshift(x1, x2, out=None, where=None, **kwargs):
+    """
+    Shift the bits of an integer to the left.
+
+    Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
+    Since the internal representation of numbers is in binary format, this
+    operation is equivalent to multiplying `x1` by ``2**x2``.
+
+    Parameters
+    ----------
+    x1 : array_like of integer type
+        Input values.
+    x2 : array_like of integer type
+        Number of zeros to append to `x1`. Has to be non-negative.
+    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 : tensor of integer type
+        Return `x1` with bits shifted `x2` times to the left.
+
+    See Also
+    --------
+    right_shift : Shift the bits of an integer to the right.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.left_shift(5, 2).execute()
+    20
+
+    >>> mt.left_shift(5, [1,2,3]).execute()
+    array([10, 20, 40])
+    """
+    op = TensorLshift(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.left_shift, reverse=True)
+def rlshift(x1, x2, **kwargs):
+    op = TensorLshift(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/maximum.py

@@ -0,0 +1,106 @@
+# 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
+class TensorMaximum(TensorBinOp):
+    _op_type_ = opcodes.MAXIMUM
+    _func_name = "maximum"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse() and np.isscalar(x2) and x2 <= 0:
+            return True
+        if hasattr(x2, "issparse") and x2.issparse() and np.isscalar(x1) and x1 <= 0:
+            return True
+        return False
+
+
+@infer_dtype(np.maximum)
+def maximum(x1, x2, out=None, where=None, **kwargs):
+    """
+    Element-wise maximum of tensor elements.
+
+    Compare two tensors and returns a new array containing the element-wise
+    maxima. If one of the elements being compared is a NaN, then that
+    element is returned. If both elements are NaNs then the first is
+    returned. The latter distinction is important for complex NaNs, which
+    are defined as at least one of the real or imaginary parts being a NaN.
+    The net effect is that NaNs are propagated.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors holding the elements to be compared. They must have
+        the same shape, or shapes that can be broadcast to a single shape.
+    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 : ndarray or scalar
+        The maximum of `x1` and `x2`, element-wise.  Returns scalar if
+        both  `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    minimum :
+        Element-wise minimum of two tensors, propagates NaNs.
+    fmax :
+        Element-wise maximum of two tensors, ignores NaNs.
+    amax :
+        The maximum value of a tensor along a given axis, propagates NaNs.
+    nanmax :
+        The maximum value of a tensor along a given axis, ignores NaNs.
+
+    fmin, amin, nanmin
+
+    Notes
+    -----
+    The maximum is equivalent to ``mt.where(x1 >= x2, x1, x2)`` when
+    neither x1 nor x2 are nans, but it is faster and does proper
+    broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.maximum([2, 3, 4], [1, 5, 2]).execute()
+    array([2, 5, 4])
+
+    >>> mt.maximum(mt.eye(2), [0.5, 2]).execute() # broadcasting
+    array([[ 1. ,  2. ],
+           [ 0.5,  2. ]])
+
+    >>> mt.maximum([mt.nan, 0, mt.nan], [0, mt.nan, mt.nan]).execute()
+    array([ NaN,  NaN,  NaN])
+    >>> mt.maximum(mt.Inf, 1).execute()
+    inf
+    """
+    op = TensorMaximum(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/minimum.py

@@ -0,0 +1,106 @@
+# 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
+class TensorMinimum(TensorBinOp):
+    _op_type_ = opcodes.MINIMUM
+    _func_name = "minimum"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse() and np.isscalar(x2) and x2 >= 0:
+            return True
+        if hasattr(x2, "issparse") and x2.issparse() and np.isscalar(x1) and x1 >= 0:
+            return True
+        return False
+
+
+@infer_dtype(np.minimum)
+def minimum(x1, x2, out=None, where=None, **kwargs):
+    """
+    Element-wise minimum of tensor elements.
+
+    Compare two tensors and returns a new tensor containing the element-wise
+    minima. If one of the elements being compared is a NaN, then that
+    element is returned. If both elements are NaNs then the first is
+    returned. The latter distinction is important for complex NaNs, which
+    are defined as at least one of the real or imaginary parts being a NaN.
+    The net effect is that NaNs are propagated.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors holding the elements to be compared. They must have
+        the same shape, or shapes that can be broadcast to a single shape.
+    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 minimum of `x1` and `x2`, element-wise.  Returns scalar if
+        both  `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    maximum :
+        Element-wise maximum of two tensors, propagates NaNs.
+    fmin :
+        Element-wise minimum of two tensors, ignores NaNs.
+    amin :
+        The minimum value of a tensor along a given axis, propagates NaNs.
+    nanmin :
+        The minimum value of a tenosr along a given axis, ignores NaNs.
+
+    fmax, amax, nanmax
+
+    Notes
+    -----
+    The minimum is equivalent to ``mt.where(x1 <= x2, x1, x2)`` when
+    neither x1 nor x2 are NaNs, but it is faster and does proper
+    broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.minimum([2, 3, 4], [1, 5, 2]).execute()
+    array([1, 3, 2])
+
+    >>> mt.minimum(mt.eye(2), [0.5, 2]).execute() # broadcasting
+    array([[ 0.5,  0. ],
+           [ 0. ,  1. ]])
+
+    >>> mt.minimum([mt.nan, 0, mt.nan],[0, mt.nan, mt.nan]).execute()
+    array([ NaN,  NaN,  NaN])
+    >>> mt.minimum(-mt.Inf, 1).execute()
+    -inf
+    """
+    op = TensorMinimum(**kwargs)
+    return op(x1, x2, out=out, where=where)