maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/misc/moveaxis.py

@@ -0,0 +1,83 @@
+# 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
+from ..utils import normalize_axis_tuple
+from .transpose import transpose
+
+
+def moveaxis(a, source, destination):
+    """
+    Move axes of a tensor to new positions.
+
+    Other axes remain in their original order.
+
+    Parameters
+    ----------
+    a : Tensor
+        The tensor whose axes should be reordered.
+    source : int or sequence of int
+        Original positions of the axes to move. These must be unique.
+    destination : int or sequence of int
+        Destination positions for each of the original axes. These must also be
+        unique.
+
+    Returns
+    -------
+    result : Tensor
+        Array with moved axes. This tensor is a view of the input tensor.
+
+    See Also
+    --------
+    transpose: Permute the dimensions of an array.
+    swapaxes: Interchange two axes of an array.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.zeros((3, 4, 5))
+    >>> mt.moveaxis(x, 0, -1).shape
+    (4, 5, 3)
+    >>> mt.moveaxis(x, -1, 0).shape
+    (5, 3, 4),
+
+    These all achieve the same result:
+
+    >>> mt.transpose(x).shape
+    (5, 4, 3)
+    >>> mt.swapaxes(x, 0, -1).shape
+    (5, 4, 3)
+    >>> mt.moveaxis(x, [0, 1], [-1, -2]).shape
+    (5, 4, 3)
+    >>> mt.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
+    (5, 4, 3)
+
+    """
+    a = astensor(a)
+
+    source = normalize_axis_tuple(source, a.ndim, "source")
+    destination = normalize_axis_tuple(destination, a.ndim, "destination")
+    if len(source) != len(destination):
+        raise ValueError(
+            "`source` and `destination` arguments must have "
+            "the same number of elements"
+        )
+
+    order = [n for n in range(a.ndim) if n not in source]
+
+    for dest, src in sorted(zip(destination, source)):
+        order.insert(dest, src)
+
+    return transpose(a, order)

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

@@ -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.
+
+import numpy as np
+
+from ..datasource import tensor as astensor
+
+
+def ravel(a, order="C"):
+    """Return a contiguous flattened tensor.
+
+    A 1-D tensor, containing the elements of the input, is returned.  A copy is
+    made only if needed.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.  The elements in `a` are packed as a 1-D tensor.
+    order : {'C','F', 'A', 'K'}, optional
+
+        The elements of `a` are read using this index order. 'C' means
+        to index the elements in row-major, C-style order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest.  'F' means to index the elements
+        in column-major, Fortran-style order, with the
+        first index changing fastest, and the last index changing
+        slowest. Note that the 'C' and 'F' options take no account of
+        the memory layout of the underlying array, and only refer to
+        the order of axis indexing.  'A' means to read the elements in
+        Fortran-like index order if `a` is Fortran *contiguous* in
+        memory, C-like order otherwise.  'K' means to read the
+        elements in the order they occur in memory, except for
+        reversing the data when strides are negative.  By default, 'C'
+        index order is used.
+
+    Returns
+    -------
+    y : array_like
+        If `a` is a matrix, y is a 1-D tensor, otherwise y is a tensor of
+        the same subtype as `a`. The shape of the returned array is
+        ``(a.size,)``. Matrices are special cased for backward
+        compatibility.
+
+    See Also
+    --------
+    Tensor.flat : 1-D iterator over an array.
+    Tensor.flatten : 1-D array copy of the elements of an array
+                      in row-major order.
+    Tensor.reshape : Change the shape of an array without changing its data.
+
+    Examples
+    --------
+    It is equivalent to ``reshape(-1)``.
+
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([[1, 2, 3], [4, 5, 6]])
+    >>> print(mt.ravel(x).execute())
+    [1 2 3 4 5 6]
+
+    >>> print(x.reshape(-1).execute())
+    [1 2 3 4 5 6]
+
+    >>> print(mt.ravel(x.T).execute())
+    [1 4 2 5 3 6]
+
+    >>> a = mt.arange(12).reshape(2,3,2).swapaxes(1,2); a.execute()
+    array([[[ 0,  2,  4],
+            [ 1,  3,  5]],
+           [[ 6,  8, 10],
+            [ 7,  9, 11]]])
+    >>> a.ravel().execute()
+    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
+
+    """
+    a = astensor(a)
+    if a.ndim == 0:
+        return a[np.newaxis]
+    return a.reshape(-1, order=order)

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

@@ -0,0 +1,88 @@
+# 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 result_type(*tensors_and_dtypes):
+    """
+    Returns the type that results from applying the NumPy
+    type promotion rules to the arguments.
+
+    Type promotion in MaxFrame works similarly to the rules in languages
+    like C++, with some slight differences.  When both scalars and
+    arrays are used, the array's type takes precedence and the actual value
+    of the scalar is taken into account.
+
+    For example, calculating 3*a, where a is an array of 32-bit floats,
+    intuitively should result in a 32-bit float output.  If the 3 is a
+    32-bit integer, the NumPy rules indicate it can't convert losslessly
+    into a 32-bit float, so a 64-bit float should be the result type.
+    By examining the value of the constant, '3', we see that it fits in
+    an 8-bit integer, which can be cast losslessly into the 32-bit float.
+
+    Parameters
+    ----------
+    tensors_and_dtypes : list of tensors and dtypes
+        The operands of some operation whose result type is needed.
+
+    Returns
+    -------
+    out : dtype
+        The result type.
+
+    See also
+    --------
+    dtype, promote_types, min_scalar_type, can_cast
+
+    Notes
+    -----
+    The specific algorithm used is as follows.
+
+    Categories are determined by first checking which of boolean,
+    integer (int/uint), or floating point (float/complex) the maximum
+    kind of all the arrays and the scalars are.
+
+    If there are only scalars or the maximum category of the scalars
+    is higher than the maximum category of the arrays,
+    the data types are combined with :func:`promote_types`
+    to produce the return value.
+
+    Otherwise, `min_scalar_type` is called on each array, and
+    the resulting data types are all combined with :func:`promote_types`
+    to produce the return value.
+
+    The set of int values is not a subset of the uint values for types
+    with the same number of bits, something not reflected in
+    :func:`min_scalar_type`, but handled as a special case in `result_type`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.result_type(3, mt.arange(7, dtype='i1'))
+    dtype('int8')
+
+    >>> mt.result_type('i4', 'c8')
+    dtype('complex128')
+
+    >>> mt.result_type(3.0, -2)
+    dtype('float64')
+    """
+    from ..core import Tensor
+
+    arrays_and_dtypes = [
+        a.dtype if isinstance(a, Tensor) else a for a in tensors_and_dtypes
+    ]
+    return np.result_type(*arrays_and_dtypes)

maxframe/tensor/misc/roll.py

@@ -0,0 +1,124 @@
+# 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
+
+import numpy as np
+
+from ..utils import validate_axis
+from .ravel import ravel
+
+
+def roll(a, shift, axis=None):
+    """
+    Roll tensor elements along a given axis.
+
+    Elements that roll beyond the last position are re-introduced at
+    the first.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    shift : int or tuple of ints
+        The number of places by which elements are shifted.  If a tuple,
+        then `axis` must be a tuple of the same size, and each of the
+        given axes is shifted by the corresponding number.  If an int
+        while `axis` is a tuple of ints, then the same value is used for
+        all given axes.
+    axis : int or tuple of ints, optional
+        Axis or axes along which elements are shifted.  By default, the
+        tensor is flattened before shifting, after which the original
+        shape is restored.
+
+    Returns
+    -------
+    res : Tensor
+        Output tensor, with the same shape as `a`.
+
+    See Also
+    --------
+    rollaxis : Roll the specified axis backwards, until it lies in a
+               given position.
+
+    Notes
+    -----
+
+    Supports rolling over multiple dimensions simultaneously.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(10)
+    >>> mt.roll(x, 2).execute()
+    array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
+
+    >>> x2 = mt.reshape(x, (2,5))
+    >>> x2.execute()
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> mt.roll(x2, 1).execute()
+    array([[9, 0, 1, 2, 3],
+           [4, 5, 6, 7, 8]])
+    >>> mt.roll(x2, 1, axis=0).execute()
+    array([[5, 6, 7, 8, 9],
+           [0, 1, 2, 3, 4]])
+    >>> mt.roll(x2, 1, axis=1).execute()
+    array([[4, 0, 1, 2, 3],
+           [9, 5, 6, 7, 8]])
+
+    """
+    from ..datasource import tensor as astensor
+    from ..merge import concatenate
+
+    a = astensor(a)
+    raw = a
+
+    if axis is None:
+        a = ravel(a)
+        axis = 0
+
+    if not isinstance(shift, Iterable):
+        shift = (shift,)
+    else:
+        shift = tuple(shift)
+    if not isinstance(axis, Iterable):
+        axis = (axis,)
+    else:
+        axis = tuple(axis)
+
+    for ax in axis:
+        validate_axis(a.ndim, ax)
+    broadcasted = np.broadcast(shift, axis)
+    if broadcasted.ndim > 1:
+        raise ValueError("'shift' and 'axis' should be scalars or 1D sequences")
+
+    shifts = {ax: 0 for ax in range(a.ndim)}
+    for s, ax in broadcasted:
+        shifts[ax] += s
+
+    for ax, s in shifts.items():
+        if s == 0:
+            continue
+
+        s = -s
+        s %= a.shape[ax]
+
+        slc1 = (slice(None),) * ax + (slice(s, None),)
+        slc2 = (slice(None),) * ax + (slice(s),)
+
+        a = concatenate([a[slc1], a[slc2]], axis=ax)
+
+    return a.reshape(raw.shape)

maxframe/tensor/misc/rollaxis.py

@@ -0,0 +1,77 @@
+# 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 validate_axis
+
+
+def rollaxis(tensor, axis, start=0):
+    """
+    Roll the specified axis backwards, until it lies in a given position.
+
+    This function continues to be supported for backward compatibility, but you
+    should prefer `moveaxis`.
+
+    Parameters
+    ----------
+    a : Tensor
+        Input tensor.
+    axis : int
+        The axis to roll backwards.  The positions of the other axes do not
+        change relative to one another.
+    start : int, optional
+        The axis is rolled until it lies before this position.  The default,
+        0, results in a "complete" roll.
+
+    Returns
+    -------
+    res : Tensor
+        a view of `a` is always returned.
+
+    See Also
+    --------
+    moveaxis : Move array axes to new positions.
+    roll : Roll the elements of an array by a number of positions along a
+        given axis.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.ones((3,4,5,6))
+    >>> mt.rollaxis(a, 3, 1).shape
+    (3, 6, 4, 5)
+    >>> mt.rollaxis(a, 2).shape
+    (5, 3, 4, 6)
+    >>> mt.rollaxis(a, 1, 4).shape
+    (3, 5, 6, 4)
+
+    """
+    n = tensor.ndim
+    axis = validate_axis(n, axis)
+    if start < 0:
+        start += n
+    msg = "'%s' arg requires %d <= %s < %d, but %d was passed in"
+    if not (0 <= start < n + 1):
+        raise np.AxisError(msg % ("start", -n, "start", n + 1, start))
+    if axis < start:
+        # it's been removed
+        start -= 1
+    if axis == start:
+        return tensor
+    axes = list(range(0, n))
+    axes.remove(axis)
+    axes.insert(start, axis)
+    return tensor.transpose(axes)