maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/datasource/full.py

@@ -0,0 +1,184 @@
+# 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 ...serialization.serializables import AnyField, KeyField, StringField
+from ..utils import get_order
+from .array import tensor
+from .core import TensorLike, TensorNoInput
+
+
+class TensorFull(TensorNoInput):
+    _op_type_ = opcodes.TENSOR_FULL
+
+    fill_value = AnyField("fill_value", default=None)
+    order = StringField("order", default=None)
+
+    def __init__(self, fill_value=None, dtype=None, **kw):
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+            if fill_value is not None:
+                fill_value = dtype.type(fill_value)
+        elif fill_value is not None:
+            dtype = np.array(fill_value).dtype
+        super().__init__(fill_value=fill_value, dtype=dtype, **kw)
+
+
+def full(shape, fill_value, dtype=None, chunk_size=None, gpu=None, order="C"):
+    """
+    Return a new tensor of given shape and type, filled with `fill_value`.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new tensor, e.g., ``(2, 3)`` or ``2``.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        The desired data-type for the tensor  The default, `None`, means
+         `np.array(fill_value).dtype`.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of `fill_value` with the given shape, dtype, and order.
+
+    See Also
+    --------
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    ones_like : Return a tensor of ones with shape and type of input.
+    empty_like : Return an empty tensor with shape and type of input.
+    full_like : Fill a tensor with shape and type of input.
+    zeros : Return a new tensor setting values to zero.
+    ones : Return a new tensor setting values to one.
+    empty : Return a new uninitialized tensor.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.full((2, 2), mt.inf).execute()
+    array([[ inf,  inf],
+           [ inf,  inf]])
+    >>> mt.full((2, 2), 10).execute()
+    array([[10, 10],
+           [10, 10]])
+
+    """
+    v = np.asarray(fill_value)
+    if len(v.shape) > 0:
+        from ..misc import broadcast_to
+
+        return broadcast_to(
+            tensor(v, dtype=dtype, chunk_size=chunk_size, gpu=gpu, order=order), shape
+        )
+
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    op = TensorFull(fill_value, dtype=dtype, gpu=gpu, order=order)
+    return op(shape, chunk_size=chunk_size, order=tensor_order)
+
+
+class TensorFullLike(TensorLike):
+    _op_type_ = opcodes.TENSOR_FULL_LIKE
+
+    _input = KeyField("input")
+    fill_value = AnyField("fill_value", default=None)
+    order = StringField("order", default=None)
+
+    def __init__(self, fill_value=None, dtype=None, gpu=None, sparse=False, **kw):
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+            if fill_value is not None:
+                fill_value = dtype.type(fill_value)
+        elif fill_value is not None:
+            dtype = np.array(fill_value).dtype
+        super().__init__(
+            fill_value=fill_value, dtype=dtype, gpu=gpu, sparse=sparse, **kw
+        )
+
+
+def full_like(a, fill_value, dtype=None, gpu=None, order="K"):
+    """
+    Return a full tensor with the same shape and type as a given tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned tensor.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, None as default
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. '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.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of `fill_value` with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty tensor with shape and type of input.
+    ones_like : Return a tensor of ones with shape and type of input.
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    full : Return a new tensor of given shape filled with value.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> x = mt.arange(6, dtype=int)
+    >>> mt.full_like(x, 1).execute()
+    array([1, 1, 1, 1, 1, 1])
+    >>> mt.full_like(x, 0.1).execute()
+    array([0, 0, 0, 0, 0, 0])
+    >>> mt.full_like(x, 0.1, dtype=mt.double).execute()
+    array([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
+    >>> mt.full_like(x, mt.nan, dtype=mt.double).execute()
+    array([ nan,  nan,  nan,  nan,  nan,  nan])
+
+    >>> y = mt.arange(6, dtype=mt.double)
+    >>> mt.full_like(y, 0.1).execute()
+    array([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
+
+    """
+    a = tensor(a)
+    tensor_order = get_order(order, a.order)
+    if dtype is None:
+        dtype = a.dtype
+    gpu = a.op.gpu if gpu is None else gpu
+    op = TensorFullLike(
+        fill_value=fill_value, dtype=dtype, gpu=gpu, sparse=a.issparse()
+    )
+    return op(a, order=tensor_order)

maxframe/tensor/datasource/identity.py

@@ -0,0 +1,54 @@
+# 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 .eye import eye
+
+
+def identity(n, dtype=None, sparse=False, gpu=None, chunk_size=None):
+    """
+    Return the identity tensor.
+
+    The identity tensor is a square array with ones on
+    the main diagonal.
+
+    Parameters
+    ----------
+    n : int
+        Number of rows (and columns) in `n` x `n` output.
+    dtype : data-type, optional
+        Data-type of the output.  Defaults to ``float``.
+    sparse: bool, optional
+        Create sparse tensor if True, False as default
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunks : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    out : Tensor
+        `n` x `n` array with its main diagonal set to one,
+        and all other elements 0.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.identity(3).execute()
+    array([[ 1.,  0.,  0.],
+           [ 0.,  1.,  0.],
+           [ 0.,  0.,  1.]])
+
+    """
+    return eye(n, dtype=dtype, sparse=sparse, gpu=gpu, chunk_size=chunk_size)

maxframe/tensor/datasource/indices.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 collections.abc import Iterable
+
+import numpy as np
+
+from .arange import arange
+from .empty import empty
+from .meshgrid import meshgrid
+
+
+def indices(dimensions, dtype=int, chunk_size=None):
+    """
+    Return a tensor representing the indices of a grid.
+
+    Compute a tensor where the subtensors contain index values 0,1,...
+    varying only along the corresponding axis.
+
+    Parameters
+    ----------
+    dimensions : sequence of ints
+        The shape of the grid.
+    dtype : dtype, optional
+        Data type of the result.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    grid : Tensor
+        The tensor of grid indices,
+        ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
+
+    See Also
+    --------
+    mgrid, meshgrid
+
+    Notes
+    -----
+    The output shape is obtained by prepending the number of dimensions
+    in front of the tuple of dimensions, i.e. if `dimensions` is a tuple
+    ``(r0, ..., rN-1)`` of length ``N``, the output shape is
+    ``(N,r0,...,rN-1)``.
+
+    The subtensors ``grid[k]`` contains the N-D array of indices along the
+    ``k-th`` axis. Explicitly::
+
+        grid[k,i0,i1,...,iN-1] = ik
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> grid = mt.indices((2, 3))
+    >>> grid.shape
+    (2, 2, 3)
+    >>> grid[0].execute()        # row indices
+    array([[0, 0, 0],
+           [1, 1, 1]])
+    >>> grid[1].execute()        # column indices
+    array([[0, 1, 2],
+           [0, 1, 2]])
+
+    The indices can be used as an index into a tensor.
+
+    >>> x = mt.arange(20).reshape(5, 4)
+    >>> row, col = mt.indices((2, 3))
+    >>> # x[row, col]
+
+    Note that it would be more straightforward in the above example to
+    extract the required elements directly with ``x[:2, :3]``.
+
+    """
+    from ..merge import stack
+
+    dimensions = tuple(dimensions)
+    dtype = np.dtype(dtype)
+    raw_chunk_size = chunk_size
+    if chunk_size is not None and isinstance(chunk_size, Iterable):
+        chunk_size = tuple(chunk_size)
+    else:
+        chunk_size = (chunk_size,) * len(dimensions)
+
+    xi = []
+    for ch, dim in zip(chunk_size, dimensions):
+        xi.append(arange(dim, dtype=dtype, chunk_size=ch))
+
+    grid = None
+    if np.prod(dimensions):
+        grid = meshgrid(*xi, indexing="ij")
+
+    if grid:
+        grid = stack(grid)
+    else:
+        if raw_chunk_size is None:
+            empty_chunk_size = None
+        else:
+            empty_chunk_size = (1,) + chunk_size
+        grid = empty(
+            (len(dimensions),) + dimensions, dtype=dtype, chunk_size=empty_chunk_size
+        )
+
+    return grid

maxframe/tensor/datasource/linspace.py

@@ -0,0 +1,140 @@
+# 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 AnyField, BoolField, Int64Field
+from .core import TensorNoInput
+
+
+class TensorLinspace(TensorNoInput):
+    _op_type_ = opcodes.TENSOR_LINSPACE
+
+    start = AnyField("start")
+    stop = AnyField("stop")
+    num = Int64Field("num")
+    endpoint = BoolField("endpoint")
+
+    def __init__(self, dtype=None, **kw):
+        dtype = np.dtype(np.linspace(0, 1, 1).dtype if dtype is None else dtype)
+        super().__init__(dtype=dtype, **kw)
+
+
+def linspace(
+    start,
+    stop,
+    num=50,
+    endpoint=True,
+    retstep=False,
+    dtype=None,
+    gpu=None,
+    chunk_size=None,
+):
+    """
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+    The endpoint of the interval can optionally be excluded.
+
+    Parameters
+    ----------
+    start : scalar
+        The starting value of the sequence.
+    stop : scalar
+        The end value of the sequence, unless `endpoint` is set to False.
+        In that case, the sequence consists of all but the last of ``num + 1``
+        evenly spaced samples, so that `stop` is excluded.  Note that the step
+        size changes when `endpoint` is False.
+    num : int, optional
+        Number of samples to generate. Default is 50. Must be non-negative.
+    endpoint : bool, optional
+        If True, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    retstep : bool, optional
+        If True, return (`samples`, `step`), where `step` is the spacing
+        between samples.
+    dtype : dtype, optional
+        The type of the output tensor.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    samples : Tensor
+        There are `num` equally spaced samples in the closed interval
+        ``[start, stop]`` or the half-open interval ``[start, stop)``
+        (depending on whether `endpoint` is True or False).
+    step : float, optional
+        Only returned if `retstep` is True
+
+        Size of spacing between samples.
+
+
+    See Also
+    --------
+    arange : Similar to `linspace`, but uses a step size (instead of the
+             number of samples).
+    logspace : Samples uniformly distributed in log space.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.linspace(2.0, 3.0, num=5).execute()
+    array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
+    >>> mt.linspace(2.0, 3.0, num=5, endpoint=False).execute()
+    array([ 2. ,  2.2,  2.4,  2.6,  2.8])
+    >>> mt.linspace(2.0, 3.0, num=5, retstep=True).execute()
+    (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 8
+    >>> y = mt.zeros(N)
+    >>> x1 = mt.linspace(0, 10, N, endpoint=True)
+    >>> x2 = mt.linspace(0, 10, N, endpoint=False)
+    >>> plt.plot(x1.execute(), y.execute(), 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(x2.execute(), y.execute() + 0.5, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.ylim([-0.5, 1])
+    (-0.5, 1)
+    >>> plt.show()
+
+    """
+    num = int(num)
+
+    op = TensorLinspace(
+        start=start, stop=stop, num=num, endpoint=endpoint, dtype=dtype, gpu=gpu
+    )
+    shape = (num,)
+    ret = op(shape, chunk_size=chunk_size)
+
+    if not retstep:
+        return ret
+
+    if num > 1:
+        step = float(stop - start) / (num if not endpoint else num - 1)
+    else:
+        step = np.nan
+
+    return ExecutableTuple([ret, step])

maxframe/tensor/datasource/meshgrid.py

@@ -0,0 +1,135 @@
+# 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 .array import tensor
+
+
+def meshgrid(*xi, **kwargs):
+    """
+    Return coordinate matrices from coordinate vectors.
+
+    Make N-D coordinate arrays for vectorized evaluations of
+    N-D scalar/vector fields over N-D grids, given
+    one-dimensional coordinate tensors x1, x2,..., xn.
+
+    Parameters
+    ----------
+    x1, x2,..., xn : array_like
+        1-D arrays representing the coordinates of a grid.
+    indexing : {'xy', 'ij'}, optional
+        Cartesian ('xy', default) or matrix ('ij') indexing of output.
+        See Notes for more details.
+    sparse : bool, optional
+        If True a sparse grid is returned in order to conserve memory.
+        Default is False.
+
+    Returns
+    -------
+    X1, X2,..., XN : Tensor
+        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
+        return ``(N1, N2, N3,...Nn)`` shaped tensors if indexing='ij'
+        or ``(N2, N1, N3,...Nn)`` shaped tensors if indexing='xy'
+        with the elements of `xi` repeated to fill the matrix along
+        the first dimension for `x1`, the second for `x2` and so on.
+
+    Notes
+    -----
+    This function supports both indexing conventions through the indexing
+    keyword argument.  Giving the string 'ij' returns a meshgrid with
+    matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
+    In the 2-D case with inputs of length M and N, the outputs are of shape
+    (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
+    with inputs of length M, N and P, outputs are of shape (N, M, P) for
+    'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
+    illustrated by the following code snippet::
+
+        xv, yv = mt.meshgrid(x, y, sparse=False, indexing='ij')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[i,j], yv[i,j]
+
+        xv, yv = mt.meshgrid(x, y, sparse=False, indexing='xy')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[j,i], yv[j,i]
+
+    In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> nx, ny = (3, 2)
+    >>> x = mt.linspace(0, 1, nx)
+    >>> y = mt.linspace(0, 1, ny)
+    >>> xv, yv = mt.meshgrid(x, y)
+    >>> xv.execute()
+    array([[ 0. ,  0.5,  1. ],
+           [ 0. ,  0.5,  1. ]])
+    >>> yv.execute()
+    array([[ 0.,  0.,  0.],
+           [ 1.,  1.,  1.]])
+    >>> xv, yv = mt.meshgrid(x, y, sparse=True)  # make sparse output arrays
+    >>> xv.execute()
+    array([[ 0. ,  0.5,  1. ]])
+    >>> yv.execute()
+    array([[ 0.],
+           [ 1.]])
+
+    `meshgrid` is very useful to evaluate functions on a grid.
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = mt.arange(-5, 5, 0.1)
+    >>> y = mt.arange(-5, 5, 0.1)
+    >>> xx, yy = mt.meshgrid(x, y, sparse=True)
+    >>> z = mt.sin(xx**2 + yy**2) / (xx**2 + yy**2)
+    >>> h = plt.contourf(x,y,z)
+
+    """
+    from ..misc import broadcast_to
+
+    indexing = kwargs.pop("indexing", "xy")
+    sparse = kwargs.pop("sparse", False)
+
+    if kwargs:
+        raise TypeError(
+            f"meshgrid() got an unexpected keyword argument '{list(kwargs)[0]}'"
+        )
+    if indexing not in ("xy", "ij"):
+        raise ValueError("Valid values for `indexing` are 'xy' and 'ij'.")
+
+    xi = [tensor(x) for x in xi]
+    xi = [a.ravel() for a in xi]
+    shape = [x.size for x in xi]
+
+    if indexing == "xy" and len(xi) > 1:
+        xi[0], xi[1] = xi[1], xi[0]
+        shape[0], shape[1] = shape[1], shape[0]
+
+    grid = []
+    for i, x in enumerate(xi):
+        slc = [None] * len(shape)
+        slc[i] = slice(None)
+
+        r = x[tuple(slc)]
+
+        if not sparse:
+            r = broadcast_to(r, shape)
+
+        grid.append(r)
+
+    if indexing == "xy" and len(xi) > 1:
+        grid[0], grid[1] = grid[1], grid[0]
+
+    return grid