maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/misc/swapaxes.py

@@ -0,0 +1,113 @@
+# 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 ... import opcodes
+from ...serialization.serializables import Int32Field
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import reverse_order, validate_axis
+
+
+class TensorSwapAxes(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.SWAPAXES
+
+    axis1 = Int32Field("axis1")
+    axis2 = Int32Field("axis2")
+
+    def __init__(self, **kw):
+        super().__init__(create_view=True, **kw)
+
+    def __call__(self, a):
+        axis1, axis2 = self.axis1, self.axis2
+        if (axis1 == 0 and axis2 == a.ndim - 1) or (axis1 == a.ndim - 1 and axis2 == 0):
+            tensor_order = reverse_order(a.order)
+        else:
+            tensor_order = TensorOrder.C_ORDER
+        shape = self._swap(a.shape, self.axis1, self.axis2)
+        return self.new_tensor([a], shape, order=tensor_order)
+
+    @staticmethod
+    def _swap(it, axis1, axis2):
+        new_it = list(it)
+        new_it[axis1], new_it[axis2] = it[axis2], it[axis1]
+
+        return tuple(new_it)
+
+    def on_output_modify(self, new_output):
+        op = TensorSwapAxes(
+            axis1=self.axis2,
+            axis2=self.axis1,
+            dtype=new_output.dtype,
+            sparse=new_output.issparse(),
+        )
+        return op(new_output)
+
+    def on_input_modify(self, new_input):
+        op = self.copy().reset_key()
+        return op(new_input)
+
+
+def swapaxes(a, axis1, axis2):
+    """
+    Interchange two axes of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis1 : int
+        First axis.
+    axis2 : int
+        Second axis.
+
+    Returns
+    -------
+    a_swapped : Tensor
+        If `a` is a Tensor, then a view of `a` is
+        returned; otherwise a new tensor is created.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([[1,2,3]])
+    >>> mt.swapaxes(x,0,1).execute()
+    array([[1],
+           [2],
+           [3]])
+
+    >>> x = mt.array([[[0,1],[2,3]],[[4,5],[6,7]]])
+    >>> x.execute()
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+
+    >>> mt.swapaxes(x,0,2).execute()
+    array([[[0, 4],
+            [2, 6]],
+           [[1, 5],
+            [3, 7]]])
+
+    """
+    a = astensor(a)
+    axis1 = validate_axis(a.ndim, axis1)
+    axis2 = validate_axis(a.ndim, axis2)
+
+    if axis1 == axis2:
+        return a
+
+    op = TensorSwapAxes(axis1=axis1, axis2=axis2, dtype=a.dtype, sparse=a.issparse())
+    return op(a)

maxframe/tensor/misc/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.

maxframe/tensor/misc/tests/test_misc.py

@@ -0,0 +1,112 @@
+# 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
+import pytest
+
+from ...datasource import arange, ones, tensor
+from .. import broadcast_to, ravel, transpose, where
+
+
+def test_dir():
+    a = tensor([0, 1, 2], chunk_size=2)
+    tensor_dir = dir(a)
+    for attr in dir(a.data):
+        assert attr in tensor_dir
+
+
+def test_astype():
+    arr = ones((10, 20, 30), chunk_size=3)
+
+    arr2 = arr.astype(np.int32)
+
+    assert arr2.shape == (10, 20, 30)
+    assert np.issubdtype(arr2.dtype, np.int32) is True
+    assert arr2.op.casting == "unsafe"
+
+    with pytest.raises(TypeError):
+        arr.astype(np.int32, casting="safe")
+
+    arr3 = arr.astype(arr.dtype, order="F")
+    assert arr3.flags["F_CONTIGUOUS"] is True
+    assert arr3.flags["C_CONTIGUOUS"] is False
+
+
+def test_transpose():
+    arr = ones((10, 20, 30), chunk_size=[4, 3, 5])
+
+    arr2 = transpose(arr)
+
+    assert arr2.shape == (30, 20, 10)
+
+    with pytest.raises(ValueError):
+        transpose(arr, axes=(1, 0))
+
+    arr3 = transpose(arr, (-2, 2, 0))
+
+    assert arr3.shape == (20, 30, 10)
+
+    arr4 = arr.transpose(-2, 2, 0)
+
+    assert arr4.shape == (20, 30, 10)
+
+    arr5 = arr.T
+
+    assert arr5.shape == (30, 20, 10)
+
+
+def test_broadcast_to():
+    arr = ones((10, 5), chunk_size=2)
+    arr2 = broadcast_to(arr, (20, 10, 5))
+
+    assert arr2.shape == (20, 10, 5)
+
+    arr = ones((10, 5, 1), chunk_size=2)
+    arr3 = broadcast_to(arr, (5, 10, 5, 6))
+
+    assert arr3.shape == (5, 10, 5, 6)
+
+    arr = ones((10, 1), chunk_size=2)
+    arr4 = broadcast_to(arr, (20, 10, 5))
+
+    assert arr4.shape == (20, 10, 5)
+
+    with pytest.raises(ValueError):
+        broadcast_to(arr, (10,))
+
+    with pytest.raises(ValueError):
+        broadcast_to(arr, (5, 1))
+
+    arr = ones((4, 5), chunk_size=2)
+    with pytest.raises((ValueError)):
+        broadcast_to(arr[arr < 2], (3, 20))
+
+
+def test_where():
+    cond = tensor([[True, False], [False, True]], chunk_size=1)
+    x = tensor([1, 2], chunk_size=1)
+
+    with pytest.raises(ValueError):
+        where(cond, x)
+
+    x = arange(9.0).reshape(3, 3)
+    y = where(x < 5, x, -1)
+
+    assert y.dtype == np.float64
+
+
+def test_ravel():
+    arr = ones((10, 5), chunk_size=2)
+    flat_arr = ravel(arr)
+    assert flat_arr.shape == (50,)

maxframe/tensor/misc/tile.py

@@ -0,0 +1,109 @@
+# 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
+
+
+def tile(A, reps):
+    """
+    Construct a tensor by repeating A the number of times given by reps.
+
+    If `reps` has length ``d``, the result will have dimension of
+    ``max(d, A.ndim)``.
+
+    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
+    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
+    or shape (1, 1, 3) for 3-D replication. If this is not the desired
+    behavior, promote `A` to d-dimensions manually before calling this
+    function.
+
+    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it.
+    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
+    (1, 1, 2, 2).
+
+    Note : Although tile may be used for broadcasting, it is strongly
+    recommended to use MaxFrame's broadcasting operations and functions.
+
+    Parameters
+    ----------
+    A : array_like
+        The input tensor.
+    reps : array_like
+        The number of repetitions of `A` along each axis.
+
+    Returns
+    -------
+    c : Tensor
+        The tiled output tensor.
+
+    See Also
+    --------
+    repeat : Repeat elements of a tensor.
+    broadcast_to : Broadcast a tensor to a new shape
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([0, 1, 2])
+    >>> mt.tile(a, 2).execute()
+    array([0, 1, 2, 0, 1, 2])
+    >>> mt.tile(a, (2, 2)).execute()
+    array([[0, 1, 2, 0, 1, 2],
+           [0, 1, 2, 0, 1, 2]])
+    >>> mt.tile(a, (2, 1, 2)).execute()
+    array([[[0, 1, 2, 0, 1, 2]],
+           [[0, 1, 2, 0, 1, 2]]])
+
+    >>> b = mt.array([[1, 2], [3, 4]])
+    >>> mt.tile(b, 2).execute()
+    array([[1, 2, 1, 2],
+           [3, 4, 3, 4]])
+    >>> mt.tile(b, (2, 1)).execute()
+    array([[1, 2],
+           [3, 4],
+           [1, 2],
+           [3, 4]])
+
+    >>> c = mt.array([1,2,3,4])
+    >>> mt.tile(c,(4,1)).execute()
+    array([[1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4]])
+    """
+    from ..merge import concatenate
+
+    try:
+        tup = tuple(reps)
+    except TypeError:
+        tup = (reps,)
+
+    d = len(tup)
+    if A.ndim < d:
+        A = A[tuple(np.newaxis for _ in range(d - A.ndim))]
+    elif A.ndim > d:
+        tup = (1,) * (A.ndim - d) + tup
+
+    a = A
+    for axis, rep in enumerate(tup):
+        if rep == 0:
+            slc = (slice(None),) * axis + (slice(0),)
+            a = a[slc]
+        elif rep < 0:
+            raise ValueError("negative dimensions are not allowed")
+        elif rep > 1:
+            a = concatenate([a] * rep, axis=axis)
+
+    return a

maxframe/tensor/misc/transpose.py

@@ -0,0 +1,133 @@
+# 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 typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import FieldTypes, KeyField, ListField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import reverse_order
+
+
+def _reorder(x, axes):
+    if x is None:
+        return
+    return type(x)(x[ax] for ax in axes)
+
+
+class TensorTranspose(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.TRANSPOSE
+
+    _input = KeyField("input")
+    axes = ListField("axes", FieldTypes.int32, default=None)
+
+    def __init__(self, axes=None, **kw):
+        # transpose will create a view
+        super().__init__(axes=axes, create_view=True, **kw)
+
+    def __call__(self, a):
+        shape = tuple(
+            s if np.isnan(s) else int(s) for s in _reorder(a.shape, self.axes)
+        )
+        if self.axes == list(reversed(range(a.ndim))):
+            # order reversed
+            tensor_order = reverse_order(a.order)
+        else:
+            tensor_order = TensorOrder.C_ORDER
+        return self.new_tensor([a], shape, order=tensor_order)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorTranspose", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
+
+    def on_output_modify(self, new_output):
+        op = self.copy().reset_key()
+        return op(new_output)
+
+    def on_input_modify(self, new_input):
+        op = self.copy().reset_key()
+        return op(new_input)
+
+
+def transpose(a, axes=None):
+    """
+    Returns an array with axes transposed.
+
+    For a 1-D array, this returns an unchanged view of the original array, as a
+    transposed vector is simply the same vector.
+    To convert a 1-D array into a 2-D column vector, an additional dimension
+    must be added, e.g., ``mt.atleast_2d(a).T`` achieves this, as does
+    ``a[:, mt.newaxis]``.
+    For a 2-D array, this is the standard matrix transpose.
+    For an n-D array, if axes are given, their order indicates how the
+    axes are permuted (see Examples). If axes are not provided, then
+    ``transpose(a).shape == a.shape[::-1]``.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axes : tuple or list of ints, optional
+        If specified, it must be a tuple or list which contains a permutation
+        of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis
+        of the returned array will correspond to the axis numbered ``axes[i]``
+        of the input. If not specified, defaults to ``range(a.ndim)[::-1]``,
+        which reverses the order of the axes.
+
+    Returns
+    -------
+    p : ndarray
+        `a` with its axes permuted. A view is returned whenever possible.
+
+    Notes
+    -----
+    Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors
+    when using the `axes` keyword argument.
+
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(4).reshape((2,2))
+    >>> x.execute()
+    array([[0, 1],
+           [2, 3]])
+
+    >>> mt.transpose(x).execute()
+    array([[0, 2],
+           [1, 3]])
+
+    >>> x = mt.ones((1, 2, 3))
+    >>> mt.transpose(x, (1, 0, 2)).shape
+    (2, 1, 3)
+
+    """
+    a = astensor(a)
+    if axes:
+        if len(axes) != a.ndim:
+            raise ValueError("axes don't match tensor")
+
+    if not axes:
+        axes = list(range(a.ndim))[::-1]
+    else:
+        axes = list(axes)
+    op = TensorTranspose(axes, dtype=a.dtype, sparse=a.issparse())
+    return op(a)

maxframe/tensor/misc/trapezoid.py

@@ -0,0 +1,123 @@
+# 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 typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import Float64Field, Int8Field, KeyField
+from ...typing_ import EntityType
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from ..utils import validate_axis
+
+
+class TensorTrapezoid(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.TRAPEZOID
+
+    y = KeyField("y")
+    x = KeyField("x")
+    dx = Float64Field("dx")
+    axis = Int8Field("axis")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorTrapezoid", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        op.y = op._inputs[0]
+        if op.x is not None:
+            op.x = op._inputs[-1]
+
+    def __call__(self, y, x=None):
+        inputs = [y]
+        order = y.order
+        if x is not None:
+            x = astensor(x)
+            inputs.append(x)
+            if x.order == TensorOrder.C_ORDER:
+                order = TensorOrder.C_ORDER
+
+        shape = tuple(s for ax, s in enumerate(y.shape) if ax != self.axis)
+        dtype = np.trapz(np.empty(1, dtype=y.dtype)).dtype
+        return self.new_tensor(inputs, shape=shape, dtype=dtype, order=order)
+
+
+def trapezoid(y, x=None, dx=1.0, axis=-1):
+    """
+    Integrate along the given axis using the composite trapezoidal rule.
+
+    Integrate `y` (`x`) along given axis.
+
+    Parameters
+    ----------
+    y : array_like
+        Input tensor to integrate.
+    x : array_like, optional
+        The sample points corresponding to the `y` values. If `x` is None,
+        the sample points are assumed to be evenly spaced `dx` apart. The
+        default is None.
+    dx : scalar, optional
+        The spacing between sample points when `x` is None. The default is 1.
+    axis : int, optional
+        The axis along which to integrate.
+
+    Returns
+    -------
+    trapezoid : float
+        Definite integral as approximated by trapezoidal rule.
+
+    See Also
+    --------
+    sum, cumsum
+
+    Notes
+    -----
+    Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
+    will be taken from `y` tensor, by default x-axis distances between
+    points will be 1.0, alternatively they can be provided with `x` tensor
+    or with `dx` scalar.  Return value will be equal to combined area under
+    the red lines.
+
+
+    References
+    ----------
+    .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
+
+    .. [2] Illustration image:
+           https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> mt.trapezoid([1,2,3]).execute()
+    4.0
+    >>> mt.trapezoid([1,2,3], x=[4,6,8]).execute()
+    8.0
+    >>> mt.trapezoid([1,2,3], dx=2).execute()
+    8.0
+    >>> a = mt.arange(6).reshape(2, 3)
+    >>> a.execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.trapezoid(a, axis=0).execute()
+    array([1.5, 2.5, 3.5])
+    >>> mt.trapezoid(a, axis=1).execute()
+    array([2.,  8.])
+
+    """
+    y = astensor(y)
+    axis = validate_axis(y.ndim, axis)
+    op = TensorTrapezoid(y=y, x=x, dx=dx, axis=axis)
+    return op(y, x=x)