maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/reduction/max.py

@@ -0,0 +1,118 @@
+# 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 ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorMax(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.MAX
+    _func_name = "max"
+
+    @classmethod
+    def _is_sparse(cls, input_sparse, shape):
+        if input_sparse and len(shape) > 0:
+            return True
+        return False
+
+
+def max(a, axis=None, out=None, keepdims=None):
+    """
+    Return the maximum of an array or maximum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        If this is a tuple of ints, the maximum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `doc.ufuncs` (Section "Output arguments") for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amax` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    amax : Tensor or scalar
+        Maximum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is a tensor of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amin :
+        The minimum value of a tensor along a given axis, propagating any NaNs.
+    nanmax :
+        The maximum value of a tensor along a given axis, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two tensors, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two tensors, ignoring any NaNs.
+    argmax :
+        Return the indices of the maximum values.
+
+    nanmin, minimum, fmin
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding max value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmax.
+
+    Don't use `amax` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+    ``amax(a, axis=0)``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(4).reshape((2,2))
+    >>> a.execute()
+    array([[0, 1],
+           [2, 3]])
+    >>> mt.amax(a).execute()           # Maximum of the flattened array
+    3
+    >>> mt.amax(a, axis=0).execute()   # Maxima along the first axis
+    array([2, 3])
+    >>> mt.amax(a, axis=1).execute()   # Maxima along the second axis
+    array([1, 3])
+
+    >>> b = mt.arange(5, dtype=float)
+    >>> b[2] = mt.NaN
+    >>> mt.amax(b).execute()
+    nan
+    >>> mt.nanmax(b).execute()
+    4.0
+
+    """
+    a = astensor(a)
+    op = TensorMax(axis=axis, dtype=a.dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/mean.py

@@ -0,0 +1,122 @@
+# 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 ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorMean(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.MEAN
+    _func_name = "mean"
+
+
+def mean(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Compute the arithmetic mean along the specified axis.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened tensor by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose mean is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the means are computed. The default is to
+        compute the mean of the flattened array.
+
+        If this is a tuple of ints, a mean is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for floating point inputs, it is the same as the
+        input dtype.
+    out : Tensor, optional
+        Alternate output tensor in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.
+        See `doc.ufuncs` for details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input tensor.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `mean` method of sub-classes of
+        `Tensor`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    m : Tensor, see dtype parameter above
+        If `out=None`, returns a new tensor containing the mean values,
+        otherwise a reference to the output array is returned.
+
+    See Also
+    --------
+    average : Weighted average
+    std, var, nanmean, nanstd, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the elements along the axis divided
+    by the number of elements.
+
+    Note that for floating-point input, the mean is computed using the
+    same precision the input has.  Depending on the input data, this can
+    cause the results to be inaccurate, especially for `float32` (see
+    example below).  Specifying a higher-precision accumulator using the
+    `dtype` keyword can alleviate this issue.
+
+    By default, `float16` results are computed using `float32` intermediates
+    for extra precision.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, 2], [3, 4]])
+    >>> mt.mean(a).execute()
+    2.5
+    >>> mt.mean(a, axis=0).execute()
+    array([ 2.,  3.])
+    >>> mt.mean(a, axis=1).execute()
+    array([ 1.5,  3.5])
+
+    In single precision, `mean` can be inaccurate:
+
+    >>> a = mt.zeros((2, 512*512), dtype=mt.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> mt.mean(a).execute()
+    0.54999924
+
+    Computing the mean in float64 is more accurate:
+
+    >>> mt.mean(a, dtype=mt.float64).execute()
+    0.55000000074505806
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.mean(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorMean(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/min.py

@@ -0,0 +1,118 @@
+# 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 ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorMin(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.MIN
+    _func_name = "min"
+
+    @classmethod
+    def _is_sparse(cls, input_sparse, shape):
+        if input_sparse and len(shape) > 0:
+            return True
+        return False
+
+
+def min(a, axis=None, out=None, keepdims=None):
+    """
+    Return the minimum of a tensor or minimum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        If this is a tuple of ints, the minimum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `doc.ufuncs` (Section "Output arguments") for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input tensor.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amin` method of sub-classes of
+        `Tensor`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    amin : Tensor or scalar
+        Minimum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amax :
+        The maximum value of a tensor along a given axis, propagating any NaNs.
+    nanmin :
+        The minimum value of a tensor along a given axis, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two tensors, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two tensors, ignoring any NaNs.
+    argmin :
+        Return the indices of the minimum values.
+
+    nanmax, maximum, fmax
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding min value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmin.
+
+    Don't use `amin` for element-wise comparison of 2 tensors; when
+    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+    ``amin(a, axis=0)``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(4).reshape((2,2))
+    >>> a.execute()
+    array([[0, 1],
+           [2, 3]])
+    >>> mt.amin(a).execute()           # Minimum of the flattened array
+    0
+    >>> mt.amin(a, axis=0).execute()   # Minima along the first axis
+    array([0, 1])
+    >>> mt.amin(a, axis=1).execute()   # Minima along the second axis
+    array([0, 2])
+
+    >>> b = mt.arange(5, dtype=float)
+    >>> b[2] = mt.NaN
+    >>> mt.amin(b).execute()
+    nan
+    >>> mt.nanmin(b).execute()
+    0.0
+
+    """
+    a = astensor(a)
+    op = TensorMin(axis=axis, dtype=a.dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanargmax.py

@@ -0,0 +1,80 @@
+# 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, TupleField
+from .core import TensorArgReductionMixin, TensorReduction
+
+
+class TensorNanArgmax(TensorReduction, TensorArgReductionMixin):
+    _op_type_ = opcodes.NANARGMAX
+    _func_name = "nanargmax"
+    _agg_func_name = "nanmax"
+
+    offset = AnyField("offset", default=None)
+    total_shape = TupleField("total_shape", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        if dtype is None:
+            dtype = np.dtype(int)
+        super().__init__(dtype=dtype, **kw)
+
+
+def nanargmax(a, axis=None, out=None):
+    """
+    Return the indices of the maximum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
+    results cannot be trusted if a slice contains only NaNs and -Infs.
+
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+    out : Tensor, optional
+        Alternate output tensor in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.
+        See `doc.ufuncs` for details.
+
+    Returns
+    -------
+    index_array : Tensor
+        An tensor of indices or a single index value.
+
+    See Also
+    --------
+    argmax, nanargmin
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[mt.nan, 4], [2, 3]])
+    >>> mt.argmax(a).execute()
+    0
+    >>> mt.nanargmax(a).execute()
+    1
+    >>> mt.nanargmax(a, axis=0).execute()
+    array([1, 0])
+    >>> mt.nanargmax(a, axis=1).execute()
+    array([1, 1])
+
+    """
+    op = TensorNanArgmax(axis=axis, dtype=np.dtype(int))
+    return op(a, out=out)

maxframe/tensor/reduction/nanargmin.py

@@ -0,0 +1,74 @@
+# 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, TupleField
+from .core import TensorArgReductionMixin, TensorReduction
+
+
+class TensorNanArgmin(TensorReduction, TensorArgReductionMixin):
+    _op_type_ = opcodes.NANARGMIN
+    _func_name = "nanargmin"
+    _agg_func_name = "nanmin"
+
+    offset = AnyField("offset", default=None)
+    total_shape = TupleField("total_shape", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        if dtype is None:
+            dtype = np.dtype(int)
+        super().__init__(dtype=dtype, **kw)
+
+
+def nanargmin(a, axis=None, out=None):
+    """
+    Return the indices of the minimum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
+    cannot be trusted if a slice contains only NaNs and Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate. By default flattened input is used.
+
+    Returns
+    -------
+    index_array : Tensor
+        A tensor of indices or a single index value.
+
+    See Also
+    --------
+    argmin, nanargmax
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[mt.nan, 4], [2, 3]])
+    >>> mt.argmin(a).execute()
+    0
+    >>> mt.nanargmin(a).execute()
+    2
+    >>> mt.nanargmin(a, axis=0).execute()
+    array([1, 1])
+    >>> mt.nanargmin(a, axis=1).execute()
+    array([1, 0])
+
+    """
+    op = TensorNanArgmin(axis=axis, dtype=np.dtype(int))
+    return op(a, out=out)

maxframe/tensor/reduction/nancumprod.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 ..datasource import tensor as astensor
+from .core import TensorCumReduction, TensorCumReductionMixin
+
+
+class TensorNanCumprod(TensorCumReduction, TensorCumReductionMixin):
+    _op_type_ = opcodes.NANCUMPROD
+    _func_name = "nancumprod"
+
+
+def nancumprod(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative product of tensor elements over a given axis treating Not a
+    Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
+    encountered and leading NaNs are replaced by ones.
+
+    Ones are returned for slices that are all-NaN or empty.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned tensor, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    nancumprod : Tensor
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    mt.cumprod : Cumulative product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.nancumprod(1).execute()
+    array([1])
+    >>> mt.nancumprod([1]).execute()
+    array([1])
+    >>> mt.nancumprod([1, mt.nan]).execute()
+    array([ 1.,  1.])
+    >>> a = mt.array([[1, 2], [3, mt.nan]])
+    >>> mt.nancumprod(a).execute()
+    array([ 1.,  2.,  6.,  6.])
+    >>> mt.nancumprod(a, axis=0).execute()
+    array([[ 1.,  2.],
+           [ 3.,  2.]])
+    >>> mt.nancumprod(a, axis=1).execute()
+    array([[ 1.,  2.],
+           [ 3.,  3.]])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nancumprod(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanCumprod(axis=axis, dtype=dtype)
+    return op(a, out=out)

maxframe/tensor/reduction/nancumsum.py

@@ -0,0 +1,92 @@
+# 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 ..datasource import tensor as astensor
+from .core import TensorCumReduction, TensorCumReductionMixin
+
+
+class TensorNanCumsum(TensorCumReduction, TensorCumReductionMixin):
+    _op_type_ = opcodes.NANCUMSUM
+    _func_name = "nancumsum"
+
+
+def nancumsum(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative sum of tensor elements over a given axis treating Not a
+    Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
+    encountered and leading NaNs are replaced by zeros.
+
+    Zeros are returned for slices that are all-NaN or empty.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened tensor.
+    dtype : dtype, optional
+        Type of the returned tensor and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See `doc.ufuncs`
+        (Section "Output arguments") for more details.
+
+    Returns
+    -------
+    nancumsum : Tensor.
+        A new tensor holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d tensor.
+
+    See Also
+    --------
+    numpy.cumsum : Cumulative sum across tensor propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.nancumsum(1).execute()
+    array([1])
+    >>> mt.nancumsum([1]).execute()
+    array([1])
+    >>> mt.nancumsum([1, mt.nan]).execute()
+    array([ 1.,  1.])
+    >>> a = mt.array([[1, 2], [3, mt.nan]])
+    >>> mt.nancumsum(a).execute()
+    array([ 1.,  3.,  6.,  6.])
+    >>> mt.nancumsum(a, axis=0).execute()
+    array([[ 1.,  2.],
+           [ 4.,  2.]])
+    >>> mt.nancumsum(a, axis=1).execute()
+    array([[ 1.,  3.],
+           [ 3.,  3.]])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nancumsum(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanCumsum(axis=axis, dtype=dtype)
+    return op(a, out=out)