maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/tensor/misc/copyto.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 List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import KeyField, StringField
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from .broadcast_to import broadcast_to
+
+
+class TensorCopyTo(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.COPYTO
+
+    src = KeyField("src")
+    dst = KeyField("dest")
+    casting = StringField("casting")
+    where = KeyField("where")
+
+    @classmethod
+    def check_inputs(cls, inputs):
+        if not 2 <= len(inputs) <= 3:
+            raise ValueError("inputs' length must be 2 or 3")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorCopyTo", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.src = inputs[0]
+        op.dst = inputs[1]
+        if len(op.inputs) > 2:
+            op.where = inputs[2]
+
+    @staticmethod
+    def _extract_inputs(inputs):
+        if len(inputs) == 2:
+            (src, dst), where = inputs, None
+        else:
+            src, dst, where = inputs
+            if where is True:
+                where = None
+            else:
+                where = astensor(where)
+
+        return src, dst, where
+
+    def __call__(self, *inputs):
+        from ..core import Tensor
+
+        src, dst, where = self._extract_inputs(inputs)
+
+        if not isinstance(dst, Tensor):
+            raise TypeError("dst has to be a Tensor")
+
+        self.dtype = dst.dtype
+        self.gpu = dst.op.gpu
+        self.sparse = dst.issparse()
+
+        if not np.can_cast(src.dtype, dst.dtype, casting=self.casting):
+            raise TypeError(
+                f"Cannot cast array from {src.dtype!r} to {dst.dtype!r} "
+                f"according to the rule {self.casting!s}"
+            )
+
+        try:
+            broadcast_to(src, dst.shape)
+        except ValueError:
+            raise ValueError(
+                "could not broadcast input array "
+                f"from shape {src.shape!r} into shape {dst.shape!r}"
+            )
+        if where is not None:
+            try:
+                broadcast_to(where, dst.shape)
+            except ValueError:
+                raise ValueError(
+                    "could not broadcast where mask "
+                    f"from shape {src.shape!r} into shape {dst.shape!r}"
+                )
+
+        inps = [src, dst]
+        if where is not None:
+            inps.append(where)
+        ret = self.new_tensor(inps, dst.shape, order=dst.order)
+        dst.data = ret.data
+
+
+def copyto(dst, src, casting="same_kind", where=True):
+    """
+    Copies values from one array to another, broadcasting as necessary.
+
+    Raises a TypeError if the `casting` rule is violated, and if
+    `where` is provided, it selects which elements to copy.
+
+    Parameters
+    ----------
+    dst : Tensor
+        The tensor into which values are copied.
+    src : array_like
+        The tensor from which values are copied.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur when copying.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+    where : array_like of bool, optional
+        A boolean tensor which is broadcasted to match the dimensions
+        of `dst`, and selects elements to copy from `src` to `dst`
+        wherever it contains the value True.
+    """
+    op = TensorCopyTo(casting=casting)
+    return op(src, dst, where)

maxframe/tensor/misc/delete.py

@@ -0,0 +1,104 @@
+# 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 EntityData
+from ...serialization.serializables import AnyField, Int32Field, Int64Field
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import calc_object_length, filter_inputs, validate_axis
+
+
+class TensorDelete(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.DELETE
+
+    index_obj = AnyField("index_obj", default=None)
+    axis = Int32Field("axis", default=None)
+
+    # for chunk
+    offset_on_axis = Int64Field("offset_on_axis", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorDelete", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if len(inputs) > 1:
+            op.index_obj = inputs[1]
+
+    def __call__(self, arr, obj, shape):
+        return self.new_tensor(filter_inputs([arr, obj]), shape=shape, order=arr.order)
+
+
+def delete(arr, obj, axis=None):
+    """
+    Return a new array with sub-arrays along an axis deleted. For a one
+    dimensional array, this returns those entries not returned by
+    `arr[obj]`.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : slice, int or array of ints
+        Indicate indices of sub-arrays to remove along the specified axis.
+    axis : int, optional
+        The axis along which to delete the subarray defined by `obj`.
+        If `axis` is None, `obj` is applied to the flattened array.
+
+    Returns
+    -------
+    out : maxframe.tensor.Tensor
+        A copy of `arr` with the elements specified by `obj` removed. Note
+        that `delete` does not occur in-place. If `axis` is None, `out` is
+        a flattened array.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> arr = mt.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
+    >>> arr.execute()
+    array([[ 1,  2,  3,  4],
+           [ 5,  6,  7,  8],
+           [ 9, 10, 11, 12]])
+    >>> mt.delete(arr, 1, 0).execute()
+    array([[ 1,  2,  3,  4],
+           [ 9, 10, 11, 12]])
+    >>> mt.delete(arr, np.s_[::2], 1).execute()
+    array([[ 2,  4],
+           [ 6,  8],
+           [10, 12]])
+    >>> mt.delete(arr, [1,3,5], None).execute()
+    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
+    """
+    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 = TensorDelete(index_obj=obj, axis=axis, dtype=arr.dtype)
+    return op(arr, obj, shape)

maxframe/tensor/misc/dsplit.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 .split import split
+
+
+def dsplit(a, indices_or_sections):
+    """
+    Split tensor into multiple sub-tensors along the 3rd axis (depth).
+
+    Please refer to the `split` documentation.  `dsplit` is equivalent
+    to `split` with ``axis=2``, the array is always split along the third
+    axis provided the tensor dimension is greater than or equal to 3.
+
+    See Also
+    --------
+    split : Split a tensor into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(16.0).reshape(2, 2, 4)
+    >>> x.execute()
+    array([[[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.]],
+           [[  8.,   9.,  10.,  11.],
+            [ 12.,  13.,  14.,  15.]]])
+    >>> mt.dsplit(x, 2).execute()
+    [array([[[  0.,   1.],
+            [  4.,   5.]],
+           [[  8.,   9.],
+            [ 12.,  13.]]]),
+     array([[[  2.,   3.],
+            [  6.,   7.]],
+           [[ 10.,  11.],
+            [ 14.,  15.]]])]
+    >>> mt.dsplit(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)]
+
+    """
+    from ..datasource import tensor as astensor
+
+    ary = a
+    a = astensor(a)
+
+    if a.ndim < 3:
+        raise ValueError("dsplit only works on tensors of 3 or more dimensions")
+    return split(ary, indices_or_sections, 2)

maxframe/tensor/misc/ediff1d.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 .ravel import ravel
+
+
+def ediff1d(a, to_end=None, to_begin=None):
+    """
+    The differences between consecutive elements of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        If necessary, will be flattened before the differences are taken.
+    to_end : array_like, optional
+        Number(s) to append at the end of the returned differences.
+    to_begin : array_like, optional
+        Number(s) to prepend at the beginning of the returned differences.
+
+    Returns
+    -------
+    ediff1d : Tensor
+        The differences. Loosely, this is ``a.flat[1:] - a.flat[:-1]``.
+
+    See Also
+    --------
+    diff, gradient
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([1, 2, 4, 7, 0])
+    >>> mt.ediff1d(x).execute()
+    array([ 1,  2,  3, -7])
+
+    >>> mt.ediff1d(x, to_begin=-99, to_end=mt.array([88, 99])).execute()
+    array([-99,   1,   2,   3,  -7,  88,  99])
+
+    The returned tensor is always 1D.
+
+    >>> y = [[1, 2, 4], [1, 6, 24]]
+    >>> mt.ediff1d(y).execute()
+    array([ 1,  2, -3,  5, 18])
+
+    """
+    from ..datasource import tensor as astensor
+    from ..merge import concatenate
+
+    a = astensor(a)
+    a = ravel(a)
+
+    t = a[1:] - a[:-1]
+    if to_begin is None and to_end is None:
+        return t
+
+    to_concat = [t]
+    if to_begin is not None:
+        to_concat.insert(0, ravel(astensor(to_begin)))
+    if to_end is not None:
+        to_concat.append(ravel(astensor(to_end)))
+
+    return concatenate(to_concat)

maxframe/tensor/misc/expand_dims.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.
+
+import numpy as np
+
+
+def expand_dims(a, axis):
+    """
+    Expand the shape of a tensor.
+
+    Insert a new axis that will appear at the `axis` position in the expanded
+    array shape.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int
+        Position in the expanded axes where the new axis is placed.
+
+    Returns
+    -------
+    res : Tensor
+        Output tensor. The number of dimensions is one greater than that of
+        the input tensor.
+
+    See Also
+    --------
+    squeeze : The inverse operation, removing singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+    doc.indexing, atleast_1d, atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([1,2])
+    >>> x.shape
+    (2,)
+
+    The following is equivalent to ``x[mt.newaxis,:]`` or ``x[mt.newaxis]``:
+
+    >>> y = mt.expand_dims(x, axis=0)
+    >>> y.execute()
+    array([[1, 2]])
+    >>> y.shape
+    (1, 2)
+
+    >>> y = mt.expand_dims(x, axis=1)  # Equivalent to x[:,mt.newaxis]
+    >>> y.execute()
+    array([[1],
+           [2]])
+    >>> y.shape
+    (2, 1)
+
+    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
+    are the same objects:
+
+    >>> mt.newaxis is None
+    True
+
+    """
+    from ..datasource import tensor as astensor
+
+    a = astensor(a)
+
+    if axis > a.ndim or axis < -a.ndim - 1:
+        raise np.AxisError(
+            f"Axis must be between -{a.ndim + 1} and {a.ndim}, got {axis}"
+        )
+
+    axis = axis if axis >= 0 else axis + a.ndim + 1
+    indexes = (slice(None),) * axis + (np.newaxis,) + (slice(None),) * (a.ndim - axis)
+    return a[indexes]

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)