maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/merge/column_stack.py

@@ -0,0 +1,63 @@
+# 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 ..datasource import tensor as astensor
+from .concatenate import concatenate
+
+
+def column_stack(tup):
+    """
+    Stack 1-D tensors as columns into a 2-D tensor.
+
+    Take a sequence of 1-D tensors and stack them as columns
+    to make a single 2-D tensor. 2-D tensors are stacked as-is,
+    just like with `hstack`.  1-D tensors are turned into 2-D columns
+    first.
+
+    Parameters
+    ----------
+    tup : sequence of 1-D or 2-D tensors.
+        Tensors to stack. All of them must have the same first dimension.
+
+    Returns
+    -------
+    stacked : 2-D tensor
+        The tensor formed by stacking the given tensors.
+
+    See Also
+    --------
+    stack, hstack, vstack, concatenate
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array((1,2,3))
+    >>> b = mt.array((2,3,4))
+    >>> mt.column_stack((a,b)).execute()
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    """
+    from ..datasource import array
+
+    arrays = []
+    for a in tup:
+        a = astensor(a)
+        if a.ndim < 2:
+            a = array(a, ndmin=2).T
+        arrays.append(a)
+
+    return concatenate(arrays, 1)

maxframe/tensor/merge/concatenate.py

@@ -0,0 +1,103 @@
+# 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 ...serialization.serializables import Int32Field
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from ..utils import validate_axis
+
+
+class TensorConcatenate(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.CONCATENATE
+
+    axis = Int32Field("axis", default=None)
+
+    def __call__(self, tensors):
+        axis = self.axis
+        shape = _calc_concatenate_shape(tensors, axis)
+        shape[axis] = sum(t.shape[axis] for t in tensors)
+        return self.new_tensor(tensors, shape=tuple(shape))
+
+
+def concatenate(tensors, axis=0):
+    """
+    Join a sequence of arrays along an existing axis.
+
+    Parameters
+    ----------
+    a1, a2, ... : sequence of array_like
+        The tensors must have the same shape, except in the dimension
+        corresponding to `axis` (the first, by default).
+    axis : int, optional
+        The axis along which the tensors will be joined.  Default is 0.
+
+    Returns
+    -------
+    res : Tensor
+        The concatenated tensor.
+
+    See Also
+    --------
+    stack : Stack a sequence of tensors along a new axis.
+    vstack : Stack tensors in sequence vertically (row wise)
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, 2], [3, 4]])
+    >>> b = mt.array([[5, 6]])
+    >>> mt.concatenate((a, b), axis=0).execute()
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    >>> mt.concatenate((a, b.T), axis=1).execute()
+    array([[1, 2, 5],
+           [3, 4, 6]])
+
+    """
+    if axis is None:
+        axis = 0
+    tensors = [astensor(t) for t in tensors]
+    axis = validate_axis(tensors[0].ndim, axis)
+
+    if len(set(t.ndim for t in tensors)) != 1:
+        raise ValueError("all the input tensors must have same number of dimensions")
+
+    shapes = [t.shape[:axis] + t.shape[axis + 1 :] for t in tensors]
+    if len(set(shapes)) != 1:
+        raise ValueError(
+            "all the input tensor dimensions "
+            "except for the concatenation axis must match exactly"
+        )
+    shape = _calc_concatenate_shape(tensors, axis)
+    if any(np.isnan(s) for i, s in enumerate(shape) if i != axis):
+        raise ValueError("cannot concatenate tensor with unknown shape")
+
+    return _concatenate(tensors, axis)
+
+
+def _concatenate(tensors, axis=0):
+    dtype = np.result_type(*(t.dtype for t in tensors))
+    sparse = all(t.issparse() for t in tensors)
+
+    op = TensorConcatenate(axis=axis, dtype=dtype, sparse=sparse)
+    return op(tensors)
+
+
+def _calc_concatenate_shape(tensors, axis):
+    return [0 if i == axis else tensors[0].shape[i] for i in range(tensors[0].ndim)]

maxframe/tensor/merge/dstack.py

@@ -0,0 +1,71 @@
+# 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 ..misc import atleast_3d
+from .concatenate import concatenate
+
+
+def dstack(tup):
+    """
+    Stack tensors in sequence depth wise (along third axis).
+
+    This is equivalent to concatenation along the third axis after 2-D tensors
+    of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
+    `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
+    `dsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of tensors
+        The tensors must have the same shape along all but the third axis.
+        1-D or 2-D arrays must have the same shape.
+
+    Returns
+    -------
+    stacked : Tensor
+        The array formed by stacking the given tensors, will be at least 3-D.
+
+    See Also
+    --------
+    stack : Join a sequence of tensors along a new axis.
+    vstack : Stack along first axis.
+    hstack : Stack along second axis.
+    concatenate : Join a sequence of arrays along an existing axis.
+    dsplit : Split tensor along third axis.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array((1,2,3))
+    >>> b = mt.array((2,3,4))
+    >>> mt.dstack((a,b)).execute()
+    array([[[1, 2],
+            [2, 3],
+            [3, 4]]])
+
+    >>> a = mt.array([[1],[2],[3]])
+    >>> b = mt.array([[2],[3],[4]])
+    >>> mt.dstack((a,b)).execute()
+    array([[[1, 2]],
+           [[2, 3]],
+           [[3, 4]]])
+
+    """
+    return concatenate([atleast_3d(t) for t in tup], axis=2)

maxframe/tensor/merge/hstack.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.
+
+from .concatenate import concatenate
+
+
+def hstack(tup):
+    """
+    Stack tensors in sequence horizontally (column wise).
+
+    This is equivalent to concatenation along the second axis, except for 1-D
+    tensors where it concatenates along the first axis. Rebuilds tensors divided
+    by `hsplit`.
+
+    This function makes most sense for tensors with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of tensors
+        The tensors must have the same shape along all but the second axis,
+        except 1-D tensors which can be any length.
+
+    Returns
+    -------
+    stacked : Tensor
+        The tensor formed by stacking the given tensors.
+
+    See Also
+    --------
+    stack : Join a sequence of tensors along a new axis.
+    vstack : Stack tensors in sequence vertically (row wise).
+    dstack : Stack tensors in sequence depth wise (along third axis).
+    concatenate : Join a sequence of tensors along an existing axis.
+    hsplit : Split tensor along second axis.
+    block : Assemble tensors from blocks.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array((1,2,3))
+    >>> b = mt.array((2,3,4))
+    >>> mt.hstack((a,b)).execute()
+    array([1, 2, 3, 2, 3, 4])
+    >>> a = mt.array([[1],[2],[3]])
+    >>> b = mt.array([[2],[3],[4]])
+    >>> mt.hstack((a,b)).execute()
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    """
+    if all(x.ndim == 1 for x in tup):
+        return concatenate(tup, axis=0)
+    else:
+        return concatenate(tup, axis=1)

maxframe/tensor/merge/stack.py

@@ -0,0 +1,130 @@
+# 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 ...serialization.serializables import Int32Field
+from ..core import Tensor, TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from ..utils import check_out_param
+
+
+class TensorStack(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.STACK
+
+    axis = Int32Field("axis", default=None)
+
+    def __call__(self, tensors, out=None):
+        if out is not None and not isinstance(out, Tensor):
+            raise TypeError(f"`out` must be a Tensor, got {type(out)} instead")
+
+        shape = (
+            tensors[0].shape[: self.axis]
+            + (len(tensors),)
+            + tensors[0].shape[self.axis :]
+        )
+        tensor_order = TensorOrder.C_ORDER if out is None else out.order
+        t = self.new_tensor(tensors, shape, order=tensor_order)
+
+        if out is None:
+            return t
+
+        if out.shape != t.shape:
+            raise ValueError("Output tensor has wrong dimensionality")
+        check_out_param(out, t, "same_kind")
+        out.data = t.data
+        return out
+
+
+def stack(tensors, axis=0, out=None):
+    """
+    Join a sequence of tensors along a new axis.
+
+    The `axis` parameter specifies the index of the new axis in the dimensions
+    of the result. For example, if ``axis=0`` it will be the first dimension
+    and if ``axis=-1`` it will be the last dimension.
+
+    Parameters
+    ----------
+    tensors : sequence of array_like
+        Each tensor must have the same shape.
+    axis : int, optional
+        The axis in the result tensor along which the input tensors are stacked.
+    out : Tensor, optional
+        If provided, the destination to place the result. The shape must be
+        correct, matching that of what stack would have returned if no
+        out argument were specified.
+
+    Returns
+    -------
+    stacked : Tensor
+        The stacked tensor has one more dimension than the input tensors.
+
+    See Also
+    --------
+    concatenate : Join a sequence of tensors along an existing axis.
+    split : Split tensor into a list of multiple sub-tensors of equal size.
+    block : Assemble tensors from blocks.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> arrays = [mt.random.randn(3, 4) for _ in range(10)]
+    >>> mt.stack(arrays, axis=0).shape
+    (10, 3, 4)
+
+    >>> mt.stack(arrays, axis=1).shape
+    (3, 10, 4)
+
+    >>> mt.stack(arrays, axis=2).shape
+    (3, 4, 10)
+
+    >>> a = mt.array([1, 2, 3])
+    >>> b = mt.array([2, 3, 4])
+    >>> mt.stack((a, b)).execute()
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> mt.stack((a, b), axis=-1).execute()
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    """
+    tensors = [astensor(t) for t in tensors]
+
+    to_check_shapes = []
+    for t in tensors:
+        if not any(np.isnan(s) for s in t.shape):
+            to_check_shapes.append(t.shape)
+    if to_check_shapes and len(set(to_check_shapes)) != 1:
+        raise ValueError("all input tensors must have the same shape")
+
+    ndim = len(tensors[0].shape)
+    raw_axis = axis
+    if axis < 0:
+        axis = ndim + axis + 1
+    if axis > ndim or axis < 0:
+        raise np.AxisError(
+            f"axis {raw_axis} is out of bounds for tensor of dimension {ndim}"
+        )
+
+    dtype = np.result_type(*[t.dtype for t in tensors])
+    sparse = all(t.issparse() for t in tensors)
+
+    op = TensorStack(axis=axis, dtype=dtype, sparse=sparse)
+    return op(tensors, out=out)

maxframe/tensor/merge/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/merge/tests/test_merge.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
+import pytest
+
+from ...datasource import empty, ones
+from .. import concatenate, stack
+
+
+def test_concatenate():
+    a = ones((10, 20, 30), chunk_size=10)
+    b = ones((20, 20, 30), chunk_size=20)
+
+    c = concatenate([a, b])
+    assert c.shape == (30, 20, 30)
+
+    a = ones((10, 20, 30), chunk_size=10)
+    b = ones((10, 20, 40), chunk_size=20)
+
+    c = concatenate([a, b], axis=-1)
+    assert c.shape == (10, 20, 70)
+
+    with pytest.raises(ValueError):
+        a = ones((10, 20, 30), chunk_size=10)
+        b = ones((20, 30, 30), chunk_size=20)
+
+        concatenate([a, b])
+
+    with pytest.raises(ValueError):
+        a = ones((10, 20, 30), chunk_size=10)
+        b = ones((20, 20), chunk_size=20)
+
+        concatenate([a, b])
+
+    a = ones((10, 20, 30), chunk_size=5)
+    b = ones((20, 20, 30), chunk_size=10)
+
+
+def test_stack():
+    raw_arrs = [ones((3, 4), chunk_size=2) for _ in range(10)]
+    arr2 = stack(raw_arrs, axis=0)
+
+    assert arr2.shape == (10, 3, 4)
+
+    arr3 = stack(raw_arrs, axis=1)
+
+    assert arr3.shape == (3, 10, 4)
+
+    arr4 = stack(raw_arrs, axis=2)
+
+    assert arr4.shape == (3, 4, 10)
+
+    with pytest.raises(ValueError):
+        raw_arrs2 = [ones((3, 4), chunk_size=2), ones((4, 3), chunk_size=2)]
+        stack(raw_arrs2)
+
+    with pytest.raises(np.AxisError):
+        stack(raw_arrs, axis=3)
+
+    with pytest.raises(np.AxisError):
+        stack(raw_arrs, axis=-4)
+
+    with pytest.raises(TypeError):
+        stack(raw_arrs, out=1)
+
+    with pytest.raises(ValueError):
+        stack(raw_arrs, empty((1, 10, 3, 4)))

maxframe/tensor/merge/vstack.py

@@ -0,0 +1,74 @@
+# 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 ..misc import atleast_2d
+from .concatenate import _concatenate, concatenate
+
+
+def vstack(tup):
+    """
+    Stack tensors in sequence vertically (row wise).
+
+    This is equivalent to concatenation along the first axis after 1-D tensors
+    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds tensors divided by
+    `vsplit`.
+
+    This function makes most sense for tensors with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of tensors
+        The tensors must have the same shape along all but the first axis.
+        1-D tensors must have the same length.
+
+    Returns
+    -------
+    stacked : Tensor
+        The tensor formed by stacking the given tensors, will be at least 2-D.
+
+    See Also
+    --------
+    stack : Join a sequence of tensors along a new axis.
+    concatenate : Join a sequence of tensors along an existing axis.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([1, 2, 3])
+    >>> b = mt.array([2, 3, 4])
+    >>> mt.vstack((a,b)).execute()
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> a = mt.array([[1], [2], [3]])
+    >>> b = mt.array([[2], [3], [4]])
+    >>> mt.vstack((a,b)).execute()
+    array([[1],
+           [2],
+           [3],
+           [2],
+           [3],
+           [4]])
+
+    """
+    return concatenate([atleast_2d(t) for t in tup], axis=0)
+
+
+def _vstack(tup):
+    return _concatenate([atleast_2d(t) for t in tup], axis=0)

maxframe/tensor/misc/__init__.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.
+
+from .argwhere import TensorArgwhere, argwhere
+from .array_split import array_split
+from .astype import TensorAstype, astype
+from .atleast_1d import atleast_1d
+from .atleast_2d import atleast_2d
+from .atleast_3d import atleast_3d
+from .broadcast_arrays import broadcast_arrays
+from .broadcast_to import TensorBroadcastTo, broadcast_to
+from .copy import copy
+from .copyto import TensorCopyTo, copyto
+from .delete import TensorDelete, delete
+from .diff import TensorDiff, diff
+from .dsplit import dsplit
+from .ediff1d import ediff1d
+from .expand_dims import expand_dims
+from .flatten import flatten
+from .flip import flip
+from .fliplr import fliplr
+from .flipud import flipud
+from .hsplit import hsplit
+from .in1d import in1d
+from .insert import insert
+from .isin import TensorIsIn, isin
+from .moveaxis import moveaxis
+from .ndim import ndim
+from .ravel import ravel
+from .repeat import TensorRepeat, repeat
+from .result_type import result_type
+from .roll import roll
+from .rollaxis import rollaxis
+from .searchsorted import TensorSearchsorted, searchsorted
+from .setdiff1d import setdiff1d
+from .shape import TensorGetShape, shape
+from .split import TensorSplit, split
+from .squeeze import TensorSqueeze, squeeze
+from .swapaxes import TensorSwapAxes, swapaxes
+from .tile import tile
+from .transpose import TensorTranspose, transpose
+from .trapezoid import TensorTrapezoid, trapezoid
+from .unique import TensorUnique, unique
+from .vsplit import vsplit
+from .where import TensorWhere, where
+
+
+def _install():
+    from ..core import Tensor, TensorData
+
+    for cls in (Tensor, TensorData):
+        setattr(cls, "astype", astype)
+        setattr(cls, "flatten", flatten)
+        setattr(cls, "ravel", ravel)
+        setattr(cls, "repeat", repeat)
+        setattr(cls, "squeeze", squeeze)
+        setattr(cls, "swapaxes", swapaxes)
+
+
+_install()
+del _install