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

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

@@ -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/merge/tests/test_merge.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/__init__.py

@@ -12,23 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .astype import TensorAstype
+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_to import TensorBroadcastTo, broadcast_to
+from .copy import copy
+from .diff import TensorDiff, diff
+from .flatten import flatten
+from .in1d import in1d
+from .isin import TensorIsIn, isin
+from .ndim import ndim
 from .ravel import ravel
-from .transpose import transpose
-from .unique import unique
+from .repeat import TensorRepeat, repeat
+from .searchsorted import TensorSearchsorted, searchsorted
+from .setdiff1d import setdiff1d
+from .squeeze import TensorSqueeze, squeeze
+from .swapaxes import TensorSwapAxes, swapaxes
+from .transpose import TensorTranspose, transpose
+from .trapezoid import TensorTrapezoid, trapezoid
+from .unique import TensorUnique, unique
 from .where import TensorWhere, where
 
 
 def _install():
     from ..core import Tensor, TensorData
-    from .astype import _astype
 
     for cls in (Tensor, TensorData):
-        setattr(cls, "astype", _astype)
+        setattr(cls, "astype", astype)
+        setattr(cls, "flatten", flatten)
+        setattr(cls, "swapaxes", swapaxes)
         setattr(cls, "ravel", ravel)
 
 

maxframe/tensor/misc/astype.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");
@@ -14,11 +12,14 @@
 # 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 ...utils import get_dtype
+from ...utils import make_dtype
 from ..operators import TensorHasInput, TensorOperatorMixin
 from ..utils import get_order
 
@@ -33,15 +34,16 @@ class TensorAstype(TensorHasInput, TensorOperatorMixin):
     def __init__(self, dtype=None, sparse=False, **kw):
         super().__init__(dtype=dtype, sparse=sparse, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self._input = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "TensorAstype", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
 
     def __call__(self, tensor, order=None):
         return self.new_tensor([tensor], tensor.shape, order=order)
 
 
-def _astype(tensor, dtype, order="K", casting="unsafe", copy=True):
+def astype(tensor, dtype, order="K", casting="unsafe", copy=True):
     """
     Copy of the tensor, cast to a specified type.
 
@@ -102,7 +104,7 @@ def _astype(tensor, dtype, order="K", casting="unsafe", copy=True):
     >>> x.astype(int).execute()
     array([1, 2, 2])
     """
-    dtype = get_dtype(dtype)
+    dtype = make_dtype(dtype)
     tensor_order = get_order(order, tensor.order)
 
     if tensor.dtype == dtype and tensor.order == tensor_order:

maxframe/tensor/misc/broadcast_to.py

@@ -85,5 +85,5 @@ def broadcast_to(tensor, shape):
             f"and requested shape {shape}"
         )
 
-    op = TensorBroadcastTo(shape, dtype=tensor.dtype, sparse=tensor.issparse())
+    op = TensorBroadcastTo(shape=shape, dtype=tensor.dtype, sparse=tensor.issparse())
     return op(tensor, shape)

maxframe/tensor/misc/copy.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.
+
+
+def copy(a, order="K"):
+    """
+    Return a tensor copy of the given object.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the copy. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible. (Note that this function and :meth:`ndarray.copy` are very
+        similar, but have different default values for their order=
+        arguments.)
+
+    Returns
+    -------
+    arr : Tensor
+        Tensor interpretation of `a`.
+
+    Notes
+    -----
+    This is equivalent to:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.array(a, copy=True)  #doctest: +SKIP
+
+    Examples
+    --------
+    Create an array x, with a reference y and a copy z:
+
+    >>> x = mt.array([1, 2, 3])
+    >>> y = x
+    >>> z = mt.copy(x)
+
+    Note that, when we modify x, y changes, but not z:
+
+    >>> x[0] = 10
+    >>> (x[0] == y[0]).execute()
+    True
+    >>> (x[0] == z[0]).execute()
+    False
+
+    """
+    from ..datasource import array
+
+    return array(a, order=order, copy=True)

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/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)

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/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)