maxframe 0.1.0b5__cp38-cp38-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/tests/test_arithmetic.py

@@ -0,0 +1,414 @@
+#!/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
+import pytest
+
+from ....core import enter_mode
+from ...core import SparseTensor, Tensor
+from ...datasource import array, empty, ones, tensor
+from .. import (
+    TensorAdd,
+    TensorGreaterThan,
+    TensorIsclose,
+    TensorLog,
+    TensorSubtract,
+    add,
+    around,
+    cos,
+    frexp,
+    isclose,
+    isfinite,
+    log,
+    negative,
+    subtract,
+    truediv,
+)
+
+
+def test_add():
+    t1 = ones((3, 4), chunk_size=2)
+    t2 = ones(4, chunk_size=2)
+    t3 = t1 + t2
+    assert t3.op.gpu is None
+    assert t3.shape == (3, 4)
+    assert t3.op.dtype == np.dtype("f8")
+
+    t1 = ones((3, 4), chunk_size=2)
+    t4 = t1 + 1
+    assert t4.shape == (3, 4)
+
+    t2 = ones(4, chunk_size=2)
+    t6 = ones((3, 4), chunk_size=2, gpu=True)
+    t7 = ones(4, chunk_size=2, gpu=True)
+    t8 = t6 + t7
+    t9 = t6 + t2
+    assert t8.op.gpu is True
+    assert t9.op.gpu is None
+
+    # sparse tests
+    t1 = tensor([[0, 1, 0], [1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 + 1
+    assert t.op.gpu is None
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t = t1 + 0
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t2 = tensor([[1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 + t2
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t3 = tensor([1, 1, 1], chunk_size=2)
+    t = t1 + t3
+    assert t.issparse() is False
+    assert type(t) is Tensor
+
+
+def test_add_order():
+    raw_a = np.random.rand(4, 2)
+    raw_b = np.asfortranarray(np.random.rand(4, 2))
+    t1 = tensor(raw_a)
+    t2 = tensor(raw_b)
+    out = tensor(raw_b)
+
+    # C + scalar
+    assert (t1 + 1).flags["C_CONTIGUOUS"] == (raw_a + 1).flags["C_CONTIGUOUS"]
+    assert (t1 + 1).flags["F_CONTIGUOUS"] == (raw_a + 1).flags["F_CONTIGUOUS"]
+    # C + C
+    assert (t1 + t1).flags["C_CONTIGUOUS"] == (raw_a + raw_a).flags["C_CONTIGUOUS"]
+    assert (t1 + t1).flags["F_CONTIGUOUS"] == (raw_a + raw_a).flags["F_CONTIGUOUS"]
+    # F + scalar
+    assert (t2 + 1).flags["C_CONTIGUOUS"] == (raw_b + 1).flags["C_CONTIGUOUS"]
+    assert (t2 + 1).flags["F_CONTIGUOUS"] == (raw_b + 1).flags["F_CONTIGUOUS"]
+    # F + F
+    assert (t2 + t2).flags["C_CONTIGUOUS"] == (raw_b + raw_b).flags["C_CONTIGUOUS"]
+    assert (t2 + t2).flags["F_CONTIGUOUS"] == (raw_b + raw_b).flags["F_CONTIGUOUS"]
+    # C + F
+    assert (t1 + t2).flags["C_CONTIGUOUS"] == (raw_a + raw_b).flags["C_CONTIGUOUS"]
+    assert (t1 + t2).flags["F_CONTIGUOUS"] == (raw_a + raw_b).flags["F_CONTIGUOUS"]
+    # C + C + out
+    assert (
+        add(t1, t1, out=out).flags["C_CONTIGUOUS"]
+        == np.add(raw_a, raw_a, out=np.empty((4, 2), order="F")).flags["C_CONTIGUOUS"]
+    )
+    assert (
+        add(t1, t1, out=out).flags["F_CONTIGUOUS"]
+        == np.add(raw_a, raw_a, out=np.empty((4, 2), order="F")).flags["F_CONTIGUOUS"]
+    )
+
+    with pytest.raises(TypeError):
+        add(t1, 1, order="B")
+
+
+def test_multiply():
+    t1 = tensor([[0, 1, 0], [1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 * 10
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t2 = tensor([[1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 * t2
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t3 = tensor([1, 1, 1], chunk_size=2)
+    t = t1 * t3
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+
+def test_divide():
+    t1 = tensor([[0, 1, 0], [1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 / 10
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+    t2 = tensor([[1, 0, 0]], chunk_size=2).tosparse()
+
+    t = t1 / t2
+    assert t.issparse() is False
+    assert type(t) is Tensor
+
+    t3 = tensor([1, 1, 1], chunk_size=2)
+    t = t1 / t3
+    assert t.issparse() is False
+    assert type(t) is Tensor
+
+    t = t3 / t1
+    assert t.issparse() is False
+    assert type(t) is Tensor
+
+
+def test_datatime_arith():
+    t1 = array([np.datetime64("2005-02-02"), np.datetime64("2005-02-03")])
+    t2 = t1 + np.timedelta64(1)
+
+    assert isinstance(t2.op, TensorAdd)
+
+    t3 = t1 - np.datetime64("2005-02-02")
+
+    assert isinstance(t3.op, TensorSubtract)
+    assert (
+        t3.dtype
+        == (
+            np.array(["2005-02-02", "2005-02-03"], dtype=np.datetime64)
+            - np.datetime64("2005-02-02")
+        ).dtype
+    )
+
+    t1 = array([np.datetime64("2005-02-02"), np.datetime64("2005-02-03")])
+    subtract(t1, np.datetime64("2005-02-02"), out=empty(t1.shape, dtype=t3.dtype))
+
+    t1 = array([np.datetime64("2005-02-02"), np.datetime64("2005-02-03")])
+    add(t1, np.timedelta64(1, "D"), out=t1)
+
+
+def test_add_with_out():
+    t1 = ones((3, 4), chunk_size=2)
+    t2 = ones(4, chunk_size=2)
+
+    t3 = add(t1, t2, out=t1)
+
+    assert isinstance(t1.op, TensorAdd)
+    assert t1.op.out.key == t1.op.lhs.key
+    assert t3 is t1
+    assert t3.shape == (3, 4)
+    assert t3.op.lhs.extra_params.raw_chunk_size == 2
+    assert t3.op.rhs is t2.data
+    assert t3.key != t3.op.lhs.key
+
+    with pytest.raises(TypeError):
+        add(t1, t2, out=1)
+
+    with pytest.raises(ValueError):
+        add(t1, t2, out=t2)
+
+    with pytest.raises(TypeError):
+        truediv(t1, t2, out=t1.astype("i8"))
+
+    t1 = ones((3, 4), chunk_size=2, dtype=float)
+    t2 = ones(4, chunk_size=2, dtype=int)
+
+    t3 = add(t2, 1, out=t1)
+    assert t3.shape == (3, 4)
+    assert t3.dtype == np.float64
+
+
+def test_dtype_from_out():
+    x = array([-np.inf, 0.0, np.inf])
+    y = array([2, 2, 2])
+
+    t3 = isfinite(x, y)
+    assert t3.dtype == y.dtype
+
+
+def test_log_without_where():
+    t1 = ones((3, 4), chunk_size=2)
+
+    t2 = log(t1, out=t1)
+
+    assert isinstance(t2.op, TensorLog)
+    assert t1.op.out.key == t1.op.input.key
+    assert t2 is t1
+    assert t2.op.input.extra_params.raw_chunk_size == 2
+    assert t2.key != t2.op.input.key
+
+    t3 = empty((3, 4), chunk_size=2)
+    t4 = log(t1, out=t3, where=t1 > 0)
+    assert isinstance(t4.op, TensorLog)
+    assert t4 is t3
+    assert t2.op.input.extra_params.raw_chunk_size == 2
+    assert t2.key != t2.op.input.key
+
+
+def test_compare():
+    t1 = ones(4, chunk_size=2) * 2
+    t2 = ones(4, chunk_size=2)
+    t3 = t1 > t2
+    assert isinstance(t3.op, TensorGreaterThan)
+
+
+def test_frexp():
+    t1 = ones((3, 4, 5), chunk_size=2)
+    t2 = empty((3, 4, 5), dtype=np.float_, chunk_size=2)
+    op_type = type(t1.op)
+
+    o1, o2 = frexp(t1)
+
+    assert o1.op is o2.op
+    assert o1.dtype != o2.dtype
+
+    o1, o2 = frexp(t1, t1)
+
+    assert o1 is t1
+    assert o1.inputs[0] is not t1
+    assert isinstance(o1.inputs[0].op, op_type)
+    assert o2.inputs[0] is not t1
+
+    o1, o2 = frexp(t1, t2, where=t1 > 0)
+
+    op_type = type(t2.op)
+    assert o1 is t2
+    assert o1.inputs[0] is not t1
+    assert isinstance(o1.inputs[0].op, op_type)
+    assert o2.inputs[0] is not t1
+
+
+def test_frexp_order():
+    raw1 = np.asfortranarray(np.random.rand(2, 4))
+    t = tensor(raw1)
+    o1 = tensor(np.random.rand(2, 4))
+
+    o1, o2 = frexp(t, out1=o1)
+
+    assert (
+        o1.flags["C_CONTIGUOUS"]
+        == np.frexp(raw1, np.empty((2, 4)))[0].flags["C_CONTIGUOUS"]
+    )
+    assert (
+        o1.flags["F_CONTIGUOUS"]
+        == np.frexp(raw1, np.empty((2, 4)))[0].flags["F_CONTIGUOUS"]
+    )
+    assert o2.flags["C_CONTIGUOUS"] == np.frexp(raw1)[1].flags["C_CONTIGUOUS"]
+    assert o2.flags["F_CONTIGUOUS"] == np.frexp(raw1)[1].flags["F_CONTIGUOUS"]
+
+
+def test_dtype():
+    t1 = ones((2, 3), dtype="f4", chunk_size=2)
+
+    t = truediv(t1, 2, dtype="f8")
+
+    assert t.dtype == np.float64
+
+    with pytest.raises(TypeError):
+        truediv(t1, 2, dtype="i4")
+
+
+def test_negative():
+    t1 = tensor([[0, 1, 0], [1, 0, 0]], chunk_size=2).tosparse()
+
+    t = negative(t1)
+    assert t.op.gpu is None
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+
+def test_negative_order():
+    raw1 = np.random.rand(4, 2)
+    raw2 = np.asfortranarray(np.random.rand(4, 2))
+    t1 = tensor(raw1)
+    t2 = tensor(raw2)
+    t3 = tensor(raw1)
+    t4 = tensor(raw2)
+
+    # C
+    assert negative(t1).flags["C_CONTIGUOUS"] == np.negative(raw1).flags["C_CONTIGUOUS"]
+    assert negative(t1).flags["F_CONTIGUOUS"] == np.negative(raw1).flags["F_CONTIGUOUS"]
+    # F
+    assert negative(t2).flags["C_CONTIGUOUS"] == np.negative(raw2).flags["C_CONTIGUOUS"]
+    assert negative(t2).flags["F_CONTIGUOUS"] == np.negative(raw2).flags["F_CONTIGUOUS"]
+    # C + out
+    assert (
+        negative(t1, out=t4).flags["C_CONTIGUOUS"]
+        == np.negative(raw1, out=np.empty((4, 2), order="F")).flags["C_CONTIGUOUS"]
+    )
+    assert (
+        negative(t1, out=t4).flags["F_CONTIGUOUS"]
+        == np.negative(raw1, out=np.empty((4, 2), order="F")).flags["F_CONTIGUOUS"]
+    )
+    # F + out
+    assert (
+        negative(t2, out=t3).flags["C_CONTIGUOUS"]
+        == np.negative(raw1, out=np.empty((4, 2), order="C")).flags["C_CONTIGUOUS"]
+    )
+    assert (
+        negative(t2, out=t3).flags["F_CONTIGUOUS"]
+        == np.negative(raw1, out=np.empty((4, 2), order="C")).flags["F_CONTIGUOUS"]
+    )
+
+    with pytest.raises(TypeError):
+        negative(t1, order="B")
+
+
+def test_cos():
+    t1 = tensor([[0, 1, 0], [1, 0, 0]], chunk_size=2).tosparse()
+
+    t = cos(t1)
+    assert t.issparse() is True
+    assert type(t) is SparseTensor
+
+
+def test_around():
+    t1 = ones((2, 3), dtype="f4", chunk_size=2)
+
+    t = around(t1, decimals=3)
+
+    assert t.issparse() is False
+    assert t.op.decimals == 3
+
+
+def test_isclose():
+    t1 = ones((2, 3), dtype="f4", chunk_size=2)
+
+    atol = 1e-4
+    rtol = 1e-5
+    equal_nan = True
+
+    t = isclose(t1, 2, atol=atol, rtol=rtol, equal_nan=equal_nan)
+
+    assert isinstance(t.op, TensorIsclose)
+    assert t.op.atol == atol
+    assert t.op.rtol == rtol
+    assert t.op.equal_nan == equal_nan
+
+    t1 = ones((2, 3), dtype="f4", chunk_size=2)
+    t2 = ones((2, 3), dtype="f4", chunk_size=2)
+
+    atol = 1e-4
+    rtol = 1e-5
+    equal_nan = True
+
+    t = isclose(t1, t2, atol=atol, rtol=rtol, equal_nan=equal_nan)
+
+    assert isinstance(t.op, TensorIsclose)
+    assert t.op.atol == atol
+    assert t.op.rtol == rtol
+    assert t.op.equal_nan == equal_nan
+
+
+def test_get_set_real():
+    a_data = np.array([1 + 2j, 3 + 4j, 5 + 6j])
+    a = tensor(a_data, chunk_size=2)
+
+    with pytest.raises(ValueError):
+        a.real = [2, 4]
+
+
+def test_build_mode():
+    t1 = ones((2, 3), chunk_size=2)
+    assert t1 == 2
+
+    with enter_mode(build=True):
+        assert t1 != 2

maxframe/tensor/arithmetic/truediv.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
+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,72 @@
+#!/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 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,65 @@
+#!/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
+
+
+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(
+                np.isscalar(x) or (hasattr(x, "issparse") and x.issparse())
+                for x in [x1, x2]
+            ):
+                return True
+            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