maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/misc/flip.py

@@ -0,0 +1,90 @@
+# 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
+
+
+def flip(m, axis):
+    """
+    Reverse the order of elements in a tensor along the given axis.
+
+    The shape of the array is preserved, but the elements are reordered.
+
+    Parameters
+    ----------
+    m : array_like
+        Input tensor.
+    axis : integer
+        Axis in tensor, which entries are reversed.
+
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the entries of axis reversed.  Since a view is
+        returned, this operation is done in constant time.
+
+    See Also
+    --------
+    flipud : Flip a tensor vertically (axis=0).
+    fliplr : Flip a tensor horizontally (axis=1).
+
+    Notes
+    -----
+    flip(m, 0) is equivalent to flipud(m).
+    flip(m, 1) is equivalent to fliplr(m).
+    flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> A = mt.arange(8).reshape((2,2,2))
+    >>> A.execute()
+    array([[[0, 1],
+            [2, 3]],
+
+           [[4, 5],
+            [6, 7]]])
+
+    >>> mt.flip(A, 0).execute()
+    array([[[4, 5],
+            [6, 7]],
+
+           [[0, 1],
+            [2, 3]]])
+
+    >>> mt.flip(A, 1).execute()
+    array([[[2, 3],
+            [0, 1]],
+
+           [[6, 7],
+            [4, 5]]])
+
+    >>> A = mt.random.randn(3,4,5)
+    >>> mt.all(mt.flip(A,2) == A[:,:,::-1,...]).execute()
+    True
+    """
+    m = astensor(m)
+
+    sl = [slice(None)] * m.ndim
+    try:
+        sl[axis] = slice(None, None, -1)
+    except IndexError:
+        raise ValueError(
+            "axis=%i is invalid for the %i-dimensional input tensor" % (axis, m.ndim)
+        )
+
+    return m[tuple(sl)]

maxframe/tensor/misc/fliplr.py

@@ -0,0 +1,64 @@
+# 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 .flip import flip
+
+
+def fliplr(m):
+    """
+    Flip tensor in the left/right direction.
+
+    Flip the entries in each row in the left/right direction.
+    Columns are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input tensor, must be at least 2-D.
+
+    Returns
+    -------
+    f : Tensor
+        A view of `m` with the columns reversed.  Since a view
+        is returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    flipud : Flip array in the up/down direction.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to m[:,::-1]. Requires the tensor to be at least 2-D.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> A = mt.diag([1.,2.,3.])
+    >>> A.execute()
+    array([[ 1.,  0.,  0.],
+           [ 0.,  2.,  0.],
+           [ 0.,  0.,  3.]])
+    >>> mt.fliplr(A).execute()
+    array([[ 0.,  0.,  1.],
+           [ 0.,  2.,  0.],
+           [ 3.,  0.,  0.]])
+
+    >>> A = mt.random.randn(2,3,5)
+    >>> mt.all(mt.fliplr(A) == A[:,::-1,...]).execute()
+    True
+
+    """
+    return flip(m, 1)

maxframe/tensor/misc/flipud.py

@@ -0,0 +1,68 @@
+# 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 .flip import flip
+
+
+def flipud(m):
+    """
+    Flip tensor in the up/down direction.
+
+    Flip the entries in each column in the up/down direction.
+    Rows are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input tensor.
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the rows reversed.  Since a view is
+        returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    fliplr : Flip tensor in the left/right direction.
+    rot90 : Rotate tensor counterclockwise.
+
+    Notes
+    -----
+    Equivalent to ``m[::-1,...]``.
+    Does not require the tensor to be two-dimensional.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> A = mt.diag([1.0, 2, 3])
+    >>> A.execute()
+    array([[ 1.,  0.,  0.],
+           [ 0.,  2.,  0.],
+           [ 0.,  0.,  3.]])
+    >>> mt.flipud(A).execute()
+    array([[ 0.,  0.,  3.],
+           [ 0.,  2.,  0.],
+           [ 1.,  0.,  0.]])
+
+    >>> A = mt.random.randn(2,3,5)
+    >>> mt.all(mt.flipud(A) == A[::-1,...]).execute()
+    True
+
+    >>> mt.flipud([1,2]).execute()
+    array([2, 1])
+
+    """
+    return flip(m, 0)

maxframe/tensor/misc/hsplit.py

@@ -0,0 +1,85 @@
+# 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 .split import split
+
+
+def hsplit(a, indices_or_sections):
+    """
+    Split a tensor into multiple sub-tensors horizontally (column-wise).
+
+    Please refer to the `split` documentation.  `hsplit` is equivalent
+    to `split` with ``axis=1``, the tensor is always split along the second
+    axis regardless of the tensor dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(16.0).reshape(4, 4)
+    >>> x.execute()
+    array([[  0.,   1.,   2.,   3.],
+           [  4.,   5.,   6.,   7.],
+           [  8.,   9.,  10.,  11.],
+           [ 12.,  13.,  14.,  15.]])
+    >>> mt.hsplit(x, 2).execute()
+    [array([[  0.,   1.],
+           [  4.,   5.],
+           [  8.,   9.],
+           [ 12.,  13.]]),
+     array([[  2.,   3.],
+           [  6.,   7.],
+           [ 10.,  11.],
+           [ 14.,  15.]])]
+    >>> mt.hsplit(x, mt.array([3, 6])).execute()
+    [array([[  0.,   1.,   2.],
+           [  4.,   5.,   6.],
+           [  8.,   9.,  10.],
+           [ 12.,  13.,  14.]]),
+     array([[  3.],
+           [  7.],
+           [ 11.],
+           [ 15.]]),
+     array([], dtype=float64)]
+
+    With a higher dimensional array the split is still along the second axis.
+
+    >>> x = mt.arange(8.0).reshape(2, 2, 2)
+    >>> x.execute()
+    array([[[ 0.,  1.],
+            [ 2.,  3.]],
+           [[ 4.,  5.],
+            [ 6.,  7.]]])
+    >>> mt.hsplit(x, 2)
+    [array([[[ 0.,  1.]],
+           [[ 4.,  5.]]]),
+     array([[[ 2.,  3.]],
+           [[ 6.,  7.]]])]
+
+    """
+    from ..datasource import tensor as astensor
+
+    ary = a
+    a = astensor(a)
+
+    if a.ndim == 0:
+        raise ValueError("hsplit only works on tensors of 1 or more dimensions")
+    if a.ndim > 1:
+        return split(ary, indices_or_sections, 1)
+    else:
+        return split(ary, indices_or_sections, 0)

maxframe/tensor/misc/in1d.py

@@ -0,0 +1,94 @@
+# 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 Union
+
+import numpy as np
+
+from ...typing_ import TileableType
+
+
+def in1d(
+    ar1: Union[TileableType, np.ndarray],
+    ar2: Union[TileableType, np.ndarray, list],
+    assume_unique: bool = False,
+    invert: bool = False,
+):
+    """
+    Test whether each element of a 1-D tensor is also present in a second tensor.
+
+    Returns a boolean tensor the same length as `ar1` that is True
+    where an element of `ar1` is in `ar2` and False otherwise.
+
+    We recommend using :func:`isin` instead of `in1d` for new code.
+
+    Parameters
+    ----------
+    ar1 : (M,) Tensor
+        Input tensor.
+    ar2 : array_like
+        The values against which to test each value of `ar1`.
+    assume_unique : bool, optional
+        If True, the input tensors are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned tensor are inverted (that is,
+        False where an element of `ar1` is in `ar2` and True otherwise).
+        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
+        to (but is faster than) ``np.invert(in1d(a, b))``.
+
+    Returns
+    -------
+    in1d : (M,) Tensor, bool
+        The values `ar1[in1d]` are in `ar2`.
+
+    See Also
+    --------
+    isin                  : Version of this function that preserves the
+                            shape of ar1.
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+    `in1d` can be considered as an element-wise function version of the
+    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
+    equivalent to ``mt.array([item in b for item in a])``.
+    However, this idea fails if `ar2` is a set, or similar (non-sequence)
+    container:  As ``ar2`` is converted to a tensor, in those cases
+    ``asarray(ar2)`` is an object tensor rather than the expected tensor of
+    contained values.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> test = mt.array([0, 1, 2, 5, 0])
+    >>> states = [0, 2]
+    >>> mask = mt.in1d(test, states)
+    >>> mask.execute()
+    array([ True, False,  True, False,  True])
+    >>> test[mask].execute()
+    array([0, 2, 0])
+    >>> mask = mt.in1d(test, states, invert=True)
+    >>> mask.execute()
+    array([False,  True, False,  True, False])
+    >>> test[mask].execute()
+    array([1, 5])
+    """
+    from .. import asarray
+    from .isin import isin
+
+    ar1 = asarray(ar1).ravel()
+    ar2 = asarray(ar2).ravel()
+    return isin(ar1, ar2, assume_unique=assume_unique, invert=invert)

maxframe/tensor/misc/insert.py

@@ -0,0 +1,139 @@
+# 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
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, EntityData
+from ...serialization.serializables import AnyField, Int32Field, TupleField
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import calc_object_length, filter_inputs, validate_axis
+
+
+class TensorInsert(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.INSERT
+
+    index_obj = AnyField("index_obj", default=None)
+    values = AnyField("values", default=None)
+    axis = Int32Field("axis", default=None)
+
+    # for chunk
+    range_on_axis = TupleField("range_on_axis", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorInsert", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(inputs[1:])
+        if isinstance(op.index_obj, ENTITY_TYPE):
+            op.index_obj = next(inputs_iter)
+        if isinstance(op.values, ENTITY_TYPE):
+            op.values = next(inputs_iter)
+
+    def __call__(self, arr, obj, values, shape):
+        return self.new_tensor(
+            filter_inputs([arr, obj, values]), shape=shape, order=arr.order
+        )
+
+
+def insert(arr, obj, values, axis=None):
+    """
+    Insert values along the given axis before the given indices.
+
+    Parameters
+    ----------
+    arr : array like
+        Input array.
+    obj : int, slice or sequence of ints
+        Object that defines the index or indices before which `values` is
+        inserted.
+    values : array_like
+        Values to insert into `arr`. If the type of `values` is different
+        from that of `arr`, `values` is converted to the type of `arr`.
+        `values` should be shaped so that ``arr[...,obj,...] = values``
+        is legal.
+    axis : int, optional
+        Axis along which to insert `values`.  If `axis` is None then `arr`
+        is flattened first.
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with `values` inserted.  Note that `insert`
+        does not occur in-place: a new array is returned. If
+        `axis` is None, `out` is a flattened array.
+    See Also
+    --------
+    append : Append elements at the end of an array.
+    concatenate : Join a sequence of arrays along an existing axis.
+    delete : Delete elements from an array.
+    Notes
+    -----
+    Note that for higher dimensional inserts `obj=0` behaves very different
+    from `obj=[0]` just like `arr[:,0,:] = values` is different from
+    `arr[:,[0],:] = values`.
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[1, 1], [2, 2], [3, 3]])
+    >>> a.execute()
+    array([[1, 1],
+           [2, 2],
+           [3, 3]])
+    >>> mt.insert(a, 1, 5).execute()
+    array([1, 5, 1, ..., 2, 3, 3])
+    >>> mt.insert(a, 1, 5, axis=1).execute()
+    array([[1, 5, 1],
+           [2, 5, 2],
+           [3, 5, 3]])
+    Difference between sequence and scalars:
+    >>> mt.insert(a, [1], [[1],[2],[3]], axis=1).execute()
+    array([[1, 1, 1],
+           [2, 2, 2],
+           [3, 3, 3]])
+    >>> b = a.flatten()
+    >>> b.execute()
+    array([1, 1, 2, 2, 3, 3])
+    >>> mt.insert(b, [2, 2], [5, 6]).execute()
+    array([1, 1, 5, ..., 2, 3, 3])
+    >>> mt.insert(b, slice(2, 4), [5, 6]).execute()
+    array([1, 1, 5, ..., 2, 3, 3])
+    >>> mt.insert(b, [2, 2], [7.13, False]).execute() # type casting
+    array([1, 1, 7, ..., 2, 3, 3])
+    >>> x = mt.arange(8).reshape(2, 4)
+    >>> idx = (1, 3)
+    >>> mt.insert(x, idx, 999, axis=1).execute()
+    array([[  0, 999,   1,   2, 999,   3],
+           [  4, 999,   5,   6, 999,   7]])
+    """
+    from ..datasource import tensor as astensor
+
+    arr = astensor(arr)
+    if getattr(obj, "ndim", 0) > 1:  # pragma: no cover
+        raise ValueError(
+            "index array argument obj to insert must be one dimensional or scalar"
+        )
+
+    if axis is None:
+        # if axis is None, array will be flatten
+        arr_size = arr.size
+        idx_length = calc_object_length(obj, size=arr_size)
+        shape = (arr_size + idx_length,)
+    else:
+        validate_axis(arr.ndim, axis)
+        idx_length = calc_object_length(obj, size=arr.shape[axis])
+        shape = tuple(
+            s + idx_length if i == axis else s for i, s in enumerate(arr.shape)
+        )
+
+    op = TensorInsert(index_obj=obj, values=values, axis=axis, dtype=arr.dtype)
+    return op(arr, obj, values, shape)

maxframe/tensor/misc/isin.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.
+
+from typing import Union
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import BoolField
+from ...typing_ import TileableType
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorIsIn(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.ISIN
+
+    assume_unique = BoolField("assume_unique")
+    invert = BoolField("invert")
+
+    def __call__(self, element, test_elements):
+        self.dtype = np.dtype(bool)
+        return self.new_tensor(
+            [element, test_elements], shape=element.shape, order=TensorOrder.C_ORDER
+        )
+
+
+def isin(
+    element: Union[TileableType, np.ndarray],
+    test_elements: Union[TileableType, np.ndarray, list],
+    assume_unique: bool = False,
+    invert: bool = False,
+):
+    """
+    Calculates `element in test_elements`, broadcasting over `element` only.
+    Returns a boolean array of the same shape as `element` that is True
+    where an element of `element` is in `test_elements` and False otherwise.
+
+    Parameters
+    ----------
+    element : array_like
+        Input tensor.
+    test_elements : array_like
+        The values against which to test each value of `element`.
+        This argument is flattened if it is a tensor or array_like.
+        See notes for behavior with non-array-like parameters.
+    assume_unique : bool, optional
+        If True, the input tensors are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned tensor are inverted, as if
+        calculating `element not in test_elements`. Default is False.
+        ``mt.isin(a, b, invert=True)`` is equivalent to (but faster
+        than) ``mt.invert(mt.isin(a, b))``.
+
+    Returns
+    -------
+    isin : Tensor, bool
+        Has the same shape as `element`. The values `element[isin]`
+        are in `test_elements`.
+
+    See Also
+    --------
+    in1d : Flattened version of this function.
+
+    Notes
+    -----
+
+    `isin` is an element-wise function version of the python keyword `in`.
+    ``isin(a, b)`` is roughly equivalent to
+    ``mt.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
+
+    `element` and `test_elements` are converted to tensors if they are not
+    already. If `test_elements` is a set (or other non-sequence collection)
+    it will be converted to an object tensor with one element, rather than a
+    tensor of the values contained in `test_elements`. This is a consequence
+    of the `tensor` constructor's way of handling non-sequence collections.
+    Converting the set to a list usually gives the desired behavior.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> element = 2*mt.arange(4).reshape((2, 2))
+    >>> element.execute()
+    array([[0, 2],
+           [4, 6]])
+    >>> test_elements = [1, 2, 4, 8]
+    >>> mask = mt.isin(element, test_elements)
+    >>> mask.execute()
+    array([[ False,  True],
+           [ True,  False]])
+    >>> element[mask].execute()
+    array([2, 4])
+    >>> mask = mt.isin(element, test_elements, invert=True)
+    >>> mask.execute()
+    array([[ True, False],
+           [ False, True]])
+    >>> element[mask]
+    array([0, 6])
+
+    Because of how `array` handles sets, the following does not
+    work as expected:
+
+    >>> test_set = {1, 2, 4, 8}
+    >>> mt.isin(element, test_set).execute()
+    array([[ False, False],
+           [ False, False]])
+
+    Casting the set to a list gives the expected result:
+
+    >>> mt.isin(element, list(test_set)).execute()
+    array([[ False,  True],
+           [ True,  False]])
+    """
+    element, test_elements = astensor(element), astensor(test_elements).ravel()
+    op = TensorIsIn(assume_unique=assume_unique, invert=invert)
+    return op(element, test_elements)