maxframe 0.1.0b5__cp311-cp311-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/logical_or.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 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,88 @@
+#!/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 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,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 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,108 @@
+#!/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 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,108 @@
+#!/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 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)

maxframe/tensor/arithmetic/mod.py

@@ -0,0 +1,104 @@
+#!/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 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,83 @@
+#!/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 .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
+
+
+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)