maxframe 1.3.0__cp38-cp38-win32.whl → 2.0.0__cp38-cp38-win32.whl

maxframe/tensor/misc/ndim.py

@@ -0,0 +1,53 @@
+# 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.
+
+
+def ndim(a):
+    """
+    Return the number of dimensions of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tebsir.  If it is not already a tensor, a conversion is
+        attempted.
+
+    Returns
+    -------
+    number_of_dimensions : int
+        The number of dimensions in `a`.  Scalars are zero-dimensional.
+
+    See Also
+    --------
+    ndarray.ndim : equivalent method
+    shape : dimensions of tensor
+    Tensor.shape : dimensions of tensor
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> mt.ndim([[1,2,3],[4,5,6]])
+    2
+    >>> mt.ndim(mt.array([[1,2,3],[4,5,6]]))
+    2
+    >>> mt.ndim(1)
+    0
+
+    """
+    from ..datasource import asarray
+
+    try:
+        return a.ndim
+    except AttributeError:
+        return asarray(a).ndim

maxframe/tensor/misc/ravel.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/misc/repeat.py

@@ -0,0 +1,129 @@
+# 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 numbers import Integral
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, Int32Field
+from ...typing_ import EntityType
+from ..core import Tensor, TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import broadcast_shape
+from .ravel import ravel
+
+
+class TensorRepeat(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.REPEAT
+
+    repeats = AnyField("repeats", default=None)
+    axis = Int32Field("axis", default=None)
+
+    def __init__(self, sparse=False, **kw):
+        super().__init__(sparse=sparse, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorRepeat", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        if len(inputs) > 1:
+            op.repeats = inputs[1]
+
+    def __call__(self, a, repeats):
+        axis = self.axis
+        a = astensor(a)
+        if axis is None:
+            a = ravel(a)
+
+        ax = axis or 0
+
+        if not isinstance(repeats, Integral):
+            if not isinstance(repeats, Tensor):
+                repeats = np.asarray(repeats)
+                if repeats.size == 1:
+                    repeats = int(repeats[0])
+                    size = repeats * a.shape[axis or 0]
+                elif a.shape[ax] == 1:
+                    size = repeats = int(repeats.sum())
+                else:
+                    size = int(repeats.sum())
+            else:
+                size = np.nan
+            if not isinstance(repeats, Integral):
+                if repeats.ndim != 1:
+                    raise ValueError("repeats should be 1-d tensor")
+                broadcast_shape(repeats.shape, a.shape[ax : ax + 1])
+        else:
+            size = a.shape[axis or 0] * repeats
+
+        shape = a.shape[:ax] + (size,) + a.shape[ax + 1 :]
+        self.dtype = a.dtype
+        self.sparse = a.issparse()
+
+        inputs = [a]
+        if isinstance(repeats, Tensor):
+            inputs.append(repeats)
+        else:
+            self.repeats = repeats
+
+        return self.new_tensor(inputs, shape, order=TensorOrder.C_ORDER)
+
+
+def repeat(a, repeats, axis=None):
+    """
+    Repeat elements of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    repeats : int or tensor of ints
+        The number of repetitions for each element.  `repeats` is broadcasted
+        to fit the shape of the given axis.
+    axis : int, optional
+        The axis along which to repeat values.  By default, use the
+        flattened input tensor, and return a flat output tensor.
+
+    Returns
+    -------
+    repeated_tensor : Tensor
+        Output array which has the same shape as `a`, except along
+        the given axis.
+
+    See Also
+    --------
+    tile : Tile a tensor.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.repeat(3, 4).execute()
+    array([3, 3, 3, 3])
+    >>> x = mt.array([[1,2],[3,4]])
+    >>> mt.repeat(x, 2).execute()
+    array([1, 1, 2, 2, 3, 3, 4, 4])
+    >>> mt.repeat(x, 3, axis=1).execute()
+    array([[1, 1, 1, 2, 2, 2],
+           [3, 3, 3, 4, 4, 4]])
+    >>> mt.repeat(x, [1, 2], axis=0).execute()
+    array([[1, 2],
+           [3, 4],
+           [3, 4]])
+
+    """
+    op = TensorRepeat(axis=axis)
+    return op(a, repeats)

maxframe/tensor/misc/searchsorted.py

@@ -0,0 +1,147 @@
+# 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 TILEABLE_TYPE, EntityData
+from ...serialization.serializables import AnyField, Int32Field, Int64Field, StringField
+from ..core import TENSOR_TYPE, TensorOrder
+from ..datasource.array import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorSearchsorted(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.SEARCHSORTED
+
+    a = AnyField("a")
+    v = AnyField("v")
+    side = StringField("side")
+    combine_size = Int32Field("combine_size")
+    # for chunk
+    offset = Int64Field("offset")
+    size = Int64Field("size")
+    n_chunk = Int64Field("n_chunk")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorSearchsorted", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.a = inputs[0]
+        if isinstance(op.v, TILEABLE_TYPE):
+            op.v = op._inputs[1]
+
+    def __call__(self, a, v):
+        inputs = [a]
+        if isinstance(v, TILEABLE_TYPE):
+            inputs.append(v)
+            shape = v.shape
+        else:
+            shape = ()
+        return self.new_tensor(inputs, shape=shape, order=TensorOrder.C_ORDER)
+
+
+def searchsorted(a, v, side="left", sorter=None, combine_size=None):
+    """
+    Find indices where elements should be inserted to maintain order.
+
+    Find the indices into a sorted tensor `a` such that, if the
+    corresponding elements in `v` were inserted before the indices, the
+    order of `a` would be preserved.
+
+    Assuming that `a` is sorted:
+
+    ======  ============================
+    `side`  returned index `i` satisfies
+    ======  ============================
+    left    ``a[i-1] < v <= a[i]``
+    right   ``a[i-1] <= v < a[i]``
+    ======  ============================
+
+    Parameters
+    ----------
+    a : 1-D array_like
+        Input tensor. If `sorter` is None, then it must be sorted in
+        ascending order, otherwise `sorter` must be an array of indices
+        that sort it.
+    v : array_like
+        Values to insert into `a`.
+    side : {'left', 'right'}, optional
+        If 'left', the index of the first suitable location found is given.
+        If 'right', return the last such index.  If there is no suitable
+        index, return either 0 or N (where N is the length of `a`).
+    sorter : 1-D array_like, optional
+        Optional tensor of integer indices that sort array a into ascending
+        order. They are typically the result of argsort.
+    combine_size: int, optional
+        The number of chunks to combine.
+
+    Returns
+    -------
+    indices : tensor of ints
+        Array of insertion points with the same shape as `v`.
+
+    See Also
+    --------
+    sort : Return a sorted copy of a tensor.
+    histogram : Produce histogram from 1-D data.
+
+    Notes
+    -----
+    Binary search is used to find the required insertion points.
+
+    This function is a faster version of the builtin python `bisect.bisect_left`
+    (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
+    which is also vectorized in the `v` argument.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.searchsorted([1,2,3,4,5], 3).execute()
+    2
+    >>> mt.searchsorted([1,2,3,4,5], 3, side='right').execute()
+    3
+    >>> mt.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]).execute()
+    array([0, 5, 1, 2])
+
+    """
+
+    if (
+        not isinstance(a, TENSOR_TYPE)
+        and sorter is not None
+        and not isinstance(sorter, TENSOR_TYPE)
+    ):
+        a = astensor(np.asarray(a)[sorter])
+    else:
+        a = astensor(a)
+        if sorter is not None:
+            a = a[sorter]
+
+    if a.ndim != 1:
+        raise ValueError("`a` should be 1-d tensor")
+    if a.issparse():
+        # does not support sparse tensor
+        raise ValueError("`a` should be a dense tensor")
+    if side not in {"left", "right"}:
+        raise ValueError(f"'{side}' is an invalid value for keyword 'side'")
+
+    if not np.isscalar(v):
+        v = astensor(v)
+
+    op = TensorSearchsorted(
+        v=v, side=side, dtype=np.dtype(np.intp), combine_size=combine_size
+    )
+    return op(a, v)

maxframe/tensor/misc/setdiff1d.py

@@ -0,0 +1,58 @@
+# 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.
+
+
+def setdiff1d(ar1, ar2, assume_unique=False):
+    """
+    Find the set difference of two tensors.
+
+    Return the unique values in `ar1` that are not in `ar2`.
+
+    Parameters
+    ----------
+    ar1 : array_like
+        Input tensor.
+    ar2 : array_like
+        Input comparison tensor.
+    assume_unique : bool
+        If True, the input tensors are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setdiff1d : Tensor
+        1D tensor of values in `ar1` that are not in `ar2`. The result
+        is sorted when `assume_unique=False`, but otherwise only sorted
+        if the input is sorted.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([1, 2, 3, 2, 4, 1])
+    >>> b = mt.array([3, 4, 5, 6])
+    >>> mt.setdiff1d(a, b).execute()
+    array([1, 2])
+
+    """
+
+    from ..datasource.array import asarray
+    from .in1d import in1d
+    from .unique import unique
+
+    if assume_unique:
+        ar1 = asarray(ar1).ravel()
+    else:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+    return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]

maxframe/tensor/misc/squeeze.py

@@ -0,0 +1,117 @@
+# 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 collections.abc import Iterable
+
+from ... import opcodes
+from ...serialization.serializables import FieldTypes, TupleField
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorSqueeze(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.SQUEEZE
+
+    axis = TupleField("axis", FieldTypes.int32)
+
+    def on_output_modify(self, new_output):
+        slcs = [slice(None)] * new_output.ndim
+        for axis in self.axis:
+            slcs.insert(axis, None)
+        return new_output[slcs]
+
+    def on_input_modify(self, new_input):
+        op = self.copy().reset_key()
+        return op(new_input, self.outputs[0].shape)
+
+    @staticmethod
+    def _get_squeeze_shape(shape, axis):
+        if axis is not None:
+            if isinstance(axis, Iterable):
+                axis = tuple(axis)
+            else:
+                axis = (axis,)
+
+            for ax in axis:
+                if shape[ax] != 1:
+                    raise ValueError(
+                        "cannot select an axis to squeeze out "
+                        "which has size not equal to one"
+                    )
+            shape = tuple(s for i, s in enumerate(shape) if i not in axis)
+        else:
+            axis = tuple(i for i, s in enumerate(shape) if s == 1)
+            shape = tuple(s for s in shape if s != 1)
+
+        return shape, axis
+
+    def __call__(self, a, shape):
+        return self.new_tensor([a], shape, order=a.order)
+
+
+def squeeze(a, axis=None):
+    """
+    Remove single-dimensional entries from the shape of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Selects a subset of the single-dimensional entries in the
+        shape. If an axis is selected with shape entry greater than
+        one, an error is raised.
+
+    Returns
+    -------
+    squeezed : Tensor
+        The input tensor, but with all or a subset of the
+        dimensions of length 1 removed. This is always `a` itself
+        or a view into `a`.
+
+    Raises
+    ------
+    ValueError
+        If `axis` is not `None`, and an axis being squeezed is not of length 1
+
+    See Also
+    --------
+    expand_dims : The inverse operation, adding singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([[[0], [1], [2]]])
+    >>> x.shape
+    (1, 3, 1)
+    >>> mt.squeeze(x).shape
+    (3,)
+    >>> mt.squeeze(x, axis=0).shape
+    (3, 1)
+    >>> mt.squeeze(x, axis=1).shape
+    Traceback (most recent call last):
+    ...
+    ValueError: cannot select an axis to squeeze out which has size not equal to one
+    >>> mt.squeeze(x, axis=2).shape
+    (1, 3)
+
+    """
+    shape, axis = TensorSqueeze._get_squeeze_shape(a.shape, axis)
+
+    if 1 not in a.shape:
+        return a
+
+    op = TensorSqueeze(axis=axis, dtype=a.dtype, sparse=a.issparse())
+    return op(a, shape)

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/test_misc.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/misc/transpose.py

@@ -12,9 +12,12 @@
 # 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
@@ -49,9 +52,10 @@ class TensorTranspose(TensorHasInput, TensorOperatorMixin):
             tensor_order = TensorOrder.C_ORDER
         return self.new_tensor([a], shape, order=tensor_order)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self._input = self._inputs[0]
+    @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()
@@ -125,5 +129,5 @@ def transpose(a, axes=None):
         axes = list(range(a.ndim))[::-1]
     else:
         axes = list(axes)
-    op = TensorTranspose(axes, dtype=a.dtype)
+    op = TensorTranspose(axes, dtype=a.dtype, sparse=a.issparse())
     return op(a)