maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/truediv.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
+class TensorTrueDiv(TensorBinOp):
+    _op_type_ = opcodes.TRUEDIV
+    _func_name = "true_divide"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if not np.isscalar(x1) and not np.isscalar(x2):
+            return False
+        if hasattr(x1, "issparse") and x1.issparse():
+            if x2 != 0:
+                return True
+            else:
+                raise ZeroDivisionError("float division by zero")
+        return False
+
+
+@infer_dtype(np.true_divide)
+def truediv(x1, x2, out=None, where=None, **kwargs):
+    """
+    Returns a true division of the inputs, element-wise.
+
+    Instead of the Python traditional 'floor division', this returns a true
+    division.  True division adjusts the output type to present the best
+    answer, regardless of input types.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Dividend tensor.
+    x2 : array_like
+        Divisor 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
+    -------
+    out : Tensor
+        Result is scalar if both inputs are scalar, tensor otherwise.
+
+    Notes
+    -----
+    The floor division operator ``//`` was added in Python 2.2 making
+    ``//`` and ``/`` equivalent operators.  The default floor division
+    operation of ``/`` can be replaced by true division with ``from
+    __future__ import division``.
+
+    In Python 3.0, ``//`` is the floor division operator and ``/`` the
+    true division operator.  The ``true_divide(x1, x2)`` function is
+    equivalent to true division in Python.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(5)
+    >>> mt.true_divide(x, 4).execute()
+    array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+    # for python 2
+    >>> (x/4).execute()
+    array([0, 0, 0, 0, 1])
+    >>> (x//4).execute()
+    array([0, 0, 0, 0, 1])
+    """
+    op = TensorTrueDiv(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.true_divide, reverse=True)
+def rtruediv(x1, x2, **kwargs):
+    op = TensorTrueDiv(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/trunc.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 infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorTrunc(TensorUnaryOp):
+    _op_type_ = opcodes.TRUNC
+    _func_name = "trunc"
+
+
+@infer_dtype(np.trunc)
+def trunc(x, out=None, where=None, **kwargs):
+    """
+    Return the truncated value of the input, element-wise.
+
+    The truncated value of the scalar `x` is the nearest integer `i` which
+    is closer to zero than `x` is. In short, the fractional part of the
+    signed number `x` is discarded.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data.
+    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 truncated value of each element in `x`.
+
+    See Also
+    --------
+    ceil, floor, rint
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+    >>> mt.trunc(a).execute()
+    array([-1., -1., -0.,  0.,  1.,  1.,  2.])
+    """
+    op = TensorTrunc(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/utils.py

@@ -0,0 +1,91 @@
+# 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 ...config import options
+
+
+def arithmetic_operator(cls=None, init=True, sparse_mode=None):
+    def _decorator(cls):
+        def __init__(self, casting="same_kind", err=None, **kw):
+            err = err if err is not None else np.geterr()
+            super(cls, self).__init__(casting=casting, err=err, **kw)
+
+        def _is_sparse_binary_and_const(x1, x2):
+            if all(np.isscalar(x) for x in [x1, x2]):
+                return False
+            if all(hasattr(x, "issparse") and x.issparse() for x in [x1, x2]):
+                return True
+            if np.isscalar(x1):
+                return cls._is_sparse_with_scalar(x1, True)
+            if np.isscalar(x2):
+                return cls._is_sparse_with_scalar(x2, False)
+            return False
+
+        def _is_sparse_binary_or_const(x1, x2):
+            if (hasattr(x1, "issparse") and x1.issparse()) or (
+                hasattr(x2, "issparse") and x2.issparse()
+            ):
+                return True
+            return False
+
+        _is_sparse_dict = dict(
+            always_false=lambda *_: False,
+            unary=lambda x: x.issparse(),
+            binary_and=_is_sparse_binary_and_const,
+            binary_or=_is_sparse_binary_or_const,
+        )
+        for v in _is_sparse_dict.values():
+            v.__name__ = "_is_sparse"
+
+        if init:
+            cls.__init__ = __init__
+
+        if sparse_mode in _is_sparse_dict:
+            cls._is_sparse = staticmethod(_is_sparse_dict[sparse_mode])
+        elif sparse_mode is not None:  # pragma: no cover
+            raise ValueError(f"Unsupported sparse mode: {sparse_mode}")
+
+        return cls
+
+    if cls is not None:
+        return _decorator(cls)
+    else:
+        return _decorator
+
+
+class TreeReductionBuilder:
+    def __init__(self, combine_size=None):
+        self._combine_size = combine_size or options.dpe.reduction.combine_size
+
+    def _build_reduction(self, inputs, final=False):
+        raise NotImplementedError
+
+    def build(self, inputs):
+        combine_size = self._combine_size
+        while len(inputs) > self._combine_size:
+            new_inputs = []
+            for i in range(0, len(inputs), combine_size):
+                objs = inputs[i : i + combine_size]
+                if len(objs) == 1:
+                    obj = objs[0]
+                else:
+                    obj = self._build_reduction(objs, final=False)
+                new_inputs.append(obj)
+            inputs = new_inputs
+
+        if len(inputs) == 1:
+            return inputs[0]
+        return self._build_reduction(inputs, final=True)

maxframe/tensor/array_utils.py

@@ -0,0 +1,164 @@
+# 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.
+
+from collections import defaultdict
+from contextlib import contextmanager
+
+import numpy as np
+
+from ..lib import sparse
+from ..lib.sparse.core import get_dense_module, issparse
+from ..utils import lazy_import
+
+cp = lazy_import("cupy", rename="cp")
+
+
+def is_array(x):
+    if isinstance(x, np.ndarray):
+        return True
+    elif isinstance(x, (sparse.SparseMatrix, sparse.SparseVector)):
+        return True
+    elif cp:  # pragma: no cover
+        return isinstance(x, cp.ndarray)
+    else:
+        return False
+
+
+def is_cupy(x):
+    if cp and isinstance(x, cp.ndarray):  # pragma: no cover
+        return True
+    else:
+        return False
+
+
+def get_array_module(x, nosparse=False):
+    if issparse(x):
+        if nosparse:
+            return get_dense_module(x)
+        return sparse
+    if cp:
+        return cp.get_array_module(x)
+    return np
+
+
+def array_module(gpu):
+    if gpu:
+        if cp is None:
+            raise ImportError("Execute on GPU requires for `cupy` library")
+        return cp
+
+    return np
+
+
+def _get(x):
+    m = get_array_module(x)
+
+    if m is np:
+        return x
+    if m is sparse:
+        return x if not hasattr(x, "get") else x.get()
+    return x.get()
+
+
+def move_to_device(x, device_id):
+    if hasattr(x, "device") and x.device.id == device_id:
+        return x
+
+    assert device_id >= 0
+
+    if issparse(x) and device_id > 0:
+        raise NotImplementedError
+
+    # for dense array, we currently copy from gpu to memory and then copy back to destination device
+    # to avoid kernel panic
+    with cp.cuda.Device(device_id):
+        return cp.asarray(cp.asnumpy(x))  # remove `cp.asnumpy` call to do directly copy
+
+
+def convert_order(x, order):
+    xp = get_array_module(x)
+    if xp.isfortran(x) != (order == "F"):
+        x = xp.array(x, order=order)
+    return x
+
+
+def _most_nbytes_device(device_nbytes):
+    device_to_nbytes = defaultdict(lambda: 0)
+    for device, nbytes in device_nbytes:
+        device_to_nbytes[device] += nbytes
+    return max(device_to_nbytes, key=lambda i: device_to_nbytes[i])
+
+
+def _is_array_writeable(a):
+    if hasattr(a, "flags") and hasattr(a.flags, "writeable"):
+        return a.flags.writeable
+    # writeable as default
+    return True
+
+
+def as_same_module(inputs, ret_extra=False, copy_if_not_writeable=False):
+    input_tensors = [
+        i for i in inputs if hasattr(i, "ndim") and i.ndim > 0
+    ]  # filter scalar
+    has_sparse = any(issparse(i) for i in inputs)
+
+    outputs = [_get(i) for i in inputs]
+
+    if copy_if_not_writeable:
+        new_outputs = []
+        for out in outputs:
+            if not _is_array_writeable(out):
+                new_outputs.append(out.copy())
+            elif isinstance(out, (sparse.SparseMatrix, sparse.SparseVector)):
+                if (
+                    not _is_array_writeable(out.data)
+                    or not _is_array_writeable(out.indices)
+                    or not _is_array_writeable(out.indptr)
+                ):
+                    new_outputs.append(type(out)(out.spmatrix.copy(), shape=out.shape))
+                else:
+                    new_outputs.append(out)
+            else:
+                new_outputs.append(out)
+        outputs = new_outputs
+
+    if not ret_extra:
+        return outputs
+
+    if has_sparse:
+        m = sparse
+    else:
+        if len(input_tensors) > 0:
+            m = get_array_module(input_tensors[0])
+        else:
+            m = np
+    return outputs, m
+
+
+def as_np_array(x):
+    xp = get_array_module(x)
+    return x if xp == np else x.get()
+
+
+def is_sparse_module(xp):
+    return xp is sparse
+
+
+@contextmanager
+def device(device_id):
+    if device_id is None or device_id < 0:
+        yield
+    else:  # pragma: no cover
+        with cp.cuda.Device(device_id) as dev:
+            yield dev