maxframe 2.4.0rc1__cp312-cp312-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/diff.py

@@ -0,0 +1,115 @@
+# 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 ...serialization.serializables import Int32Field, Int64Field
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from ..utils import validate_axis
+
+
+class TensorDiff(TensorOperator, TensorOperatorMixin):
+    n = Int64Field("n")
+    axis = Int32Field("axis")
+
+    def __call__(self, a):
+        shape = list(a.shape)
+        shape[self.axis] -= self.n
+        shape = tuple(shape)
+        return self.new_tensor([a], shape, dtype=a.dtype, order=a.order)
+
+
+def diff(a, n=1, axis=-1):
+    """
+    Calculate the n-th discrete difference along the given axis.
+
+    The first difference is given by ``out[n] = a[n+1] - a[n]`` along
+    the given axis, higher differences are calculated by using `diff`
+    recursively.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor
+    n : int, optional
+        The number of times values are differenced. If zero, the input
+        is returned as-is.
+    axis : int, optional
+        The axis along which the difference is taken, default is the
+        last axis.
+
+    Returns
+    -------
+    diff : Tensor
+        The n-th differences. The shape of the output is the same as `a`
+        except along `axis` where the dimension is smaller by `n`. The
+        type of the output is the same as the type of the difference
+        between any two elements of `a`. This is the same as the type of
+        `a` in most cases. A notable exception is `datetime64`, which
+        results in a `timedelta64` output tensor.
+
+    See Also
+    --------
+    gradient, ediff1d, cumsum
+
+    Notes
+    -----
+    Type is preserved for boolean tensors, so the result will contain
+    `False` when consecutive elements are the same and `True` when they
+    differ.
+
+    For unsigned integer tensors, the results will also be unsigned. This
+    should not be surprising, as the result is consistent with
+    calculating the difference directly:
+
+    >>> import maxframe.tensor as mt
+
+    >>> u8_arr = mt.array([1, 0], dtype=mt.uint8)
+    >>> mt.diff(u8_arr).execute()
+    array([255], dtype=uint8)
+    >>> (u8_arr[1,...] - u8_arr[0,...]).execute()
+    255
+
+    If this is not desirable, then the array should be cast to a larger
+    integer type first:
+
+    >>> i16_arr = u8_arr.astype(mt.int16)
+    >>> mt.diff(i16_arr).execute()
+    array([-1], dtype=int16)
+
+    Examples
+    --------
+    >>> x = mt.array([1, 2, 4, 7, 0])
+    >>> mt.diff(x).execute()
+    array([ 1,  2,  3, -7])
+    >>> mt.diff(x, n=2).execute()
+    array([  1,   1, -10])
+
+    >>> x = mt.array([[1, 3, 6, 10], [0, 5, 6, 8]])
+    >>> mt.diff(x).execute()
+    array([[2, 3, 4],
+           [5, 1, 2]])
+    >>> mt.diff(x, axis=0).execute()
+    array([[-1,  2,  0, -2]])
+
+    >>> x = mt.arange('1066-10-13', '1066-10-16', dtype=mt.datetime64)
+    >>> mt.diff(x).execute()
+    array([1, 1], dtype='timedelta64[D]')
+
+    """
+    a = astensor(a)
+    n = int(n)
+
+    axis = validate_axis(a.ndim, axis)
+    op = TensorDiff(axis=axis, n=n)
+    return op(a)

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/flatten.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.
+
+import numpy as np
+
+from ..utils import get_order
+
+
+def flatten(a, order="C"):
+    """
+    Return a copy of the tensor collapsed into one dimension.
+
+    Parameters
+    ----------
+    order : {'C', 'F', 'A', 'K'}, optional
+        'C' means to flatten in row-major (C-style) order.
+        'F' means to flatten in column-major (Fortran-
+        style) order. 'A' means to flatten in column-major
+        order if `a` is Fortran *contiguous* in memory,
+        row-major order otherwise. 'K' means to flatten
+        `a` in the order the elements occur in memory.
+        The default is 'C'.
+
+    Returns
+    -------
+    y : Tensor
+        A copy of the input tensor, flattened to one dimension.
+
+    See Also
+    --------
+    ravel : Return a flattened tensor.
+    flat : A 1-D flat iterator over the tensor.
+
+    Examples
+    --------
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1,2], [3,4]])
+    >>> a.flatten().execute()
+    array([1, 2, 3, 4])
+    """
+
+    from ..reshape.reshape import TensorReshape, calc_shape
+
+    if a.ndim == 1:
+        return a
+
+    new_shape = np.nan if any(np.isnan(s) for s in a.shape) else calc_shape(a.size, -1)
+    tensor_order = get_order(order, a.order)
+    op = TensorReshape(newshape=new_shape, dtype=a.dtype, create_view=False)
+    return op(a, order=tensor_order, out_shape=new_shape)