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

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

maxframe/tensor/misc/insert.py

@@ -0,0 +1,139 @@
+# 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 ENTITY_TYPE, EntityData
+from ...serialization.serializables import AnyField, Int32Field, TupleField
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import calc_object_length, filter_inputs, validate_axis
+
+
+class TensorInsert(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.INSERT
+
+    index_obj = AnyField("index_obj", default=None)
+    values = AnyField("values", default=None)
+    axis = Int32Field("axis", default=None)
+
+    # for chunk
+    range_on_axis = TupleField("range_on_axis", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorInsert", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(inputs[1:])
+        if isinstance(op.index_obj, ENTITY_TYPE):
+            op.index_obj = next(inputs_iter)
+        if isinstance(op.values, ENTITY_TYPE):
+            op.values = next(inputs_iter)
+
+    def __call__(self, arr, obj, values, shape):
+        return self.new_tensor(
+            filter_inputs([arr, obj, values]), shape=shape, order=arr.order
+        )
+
+
+def insert(arr, obj, values, axis=None):
+    """
+    Insert values along the given axis before the given indices.
+
+    Parameters
+    ----------
+    arr : array like
+        Input array.
+    obj : int, slice or sequence of ints
+        Object that defines the index or indices before which `values` is
+        inserted.
+    values : array_like
+        Values to insert into `arr`. If the type of `values` is different
+        from that of `arr`, `values` is converted to the type of `arr`.
+        `values` should be shaped so that ``arr[...,obj,...] = values``
+        is legal.
+    axis : int, optional
+        Axis along which to insert `values`.  If `axis` is None then `arr`
+        is flattened first.
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with `values` inserted.  Note that `insert`
+        does not occur in-place: a new array is returned. If
+        `axis` is None, `out` is a flattened array.
+    See Also
+    --------
+    append : Append elements at the end of an array.
+    concatenate : Join a sequence of arrays along an existing axis.
+    delete : Delete elements from an array.
+    Notes
+    -----
+    Note that for higher dimensional inserts `obj=0` behaves very different
+    from `obj=[0]` just like `arr[:,0,:] = values` is different from
+    `arr[:,[0],:] = values`.
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[1, 1], [2, 2], [3, 3]])
+    >>> a.execute()
+    array([[1, 1],
+           [2, 2],
+           [3, 3]])
+    >>> mt.insert(a, 1, 5).execute()
+    array([1, 5, 1, ..., 2, 3, 3])
+    >>> mt.insert(a, 1, 5, axis=1).execute()
+    array([[1, 5, 1],
+           [2, 5, 2],
+           [3, 5, 3]])
+    Difference between sequence and scalars:
+    >>> mt.insert(a, [1], [[1],[2],[3]], axis=1).execute()
+    array([[1, 1, 1],
+           [2, 2, 2],
+           [3, 3, 3]])
+    >>> b = a.flatten()
+    >>> b.execute()
+    array([1, 1, 2, 2, 3, 3])
+    >>> mt.insert(b, [2, 2], [5, 6]).execute()
+    array([1, 1, 5, ..., 2, 3, 3])
+    >>> mt.insert(b, slice(2, 4), [5, 6]).execute()
+    array([1, 1, 5, ..., 2, 3, 3])
+    >>> mt.insert(b, [2, 2], [7.13, False]).execute() # type casting
+    array([1, 1, 7, ..., 2, 3, 3])
+    >>> x = mt.arange(8).reshape(2, 4)
+    >>> idx = (1, 3)
+    >>> mt.insert(x, idx, 999, axis=1).execute()
+    array([[  0, 999,   1,   2, 999,   3],
+           [  4, 999,   5,   6, 999,   7]])
+    """
+    from ..datasource import tensor as astensor
+
+    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 = TensorInsert(index_obj=obj, values=values, axis=axis, dtype=arr.dtype)
+    return op(arr, obj, values, shape)

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

maxframe/tensor/misc/shape.py

@@ -0,0 +1,89 @@
+# 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 ... import opcodes
+from ...core import ExecutableTuple
+from ...serialization.serializables import Int32Field
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorGetShape(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.GET_SHAPE
+
+    ndim = Int32Field("ndim")
+
+    def __init__(self, pure_depends=None, **kw):
+        super().__init__(_pure_depends=pure_depends, **kw)
+
+    @property
+    def output_limit(self):
+        return self.ndim
+
+    def __call__(self, a):
+        if not np.isnan(a.size):
+            return ExecutableTuple([astensor(s) for s in a.shape])
+
+        kws = []
+        for i in range(self.output_limit):
+            kws.append(
+                {
+                    "shape": (),
+                    "dtype": np.dtype(np.intc),
+                    "order": TensorOrder.C_ORDER,
+                    "i": i,
+                }
+            )
+        return ExecutableTuple(self.new_tensors([a], kws=kws))
+
+
+def shape(a):
+    """
+    Return the shape of a tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+
+    Returns
+    -------
+    shape : ExecutableTuple of tensors
+        The elements of the shape tuple give the lengths of the
+        corresponding array dimensions.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.shape(mt.eye(3)).execute()
+    (3, 3)
+    >>> mt.shape([[1, 2]]).execute()
+    (1, 2)
+    >>> mt.shape([0]).execute()
+    (1,)
+    >>> mt.shape(0).execute()
+    ()
+
+    >>> a = mt.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+    >>> mt.shape(a).execute()
+    (2,)
+
+    """
+    a = astensor(a)
+    op = TensorGetShape(ndim=a.ndim)
+    return op(a)