maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/reduction/nanmax.py

@@ -0,0 +1,109 @@
+# 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 TensorNanMax(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANMAX
+    _func_name = "nanmax"
+
+
+def nanmax(a, axis=None, out=None, keepdims=None):
+    """
+    Return the maximum of an array or maximum along an axis, ignoring any
+    NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
+    raised and NaN is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose maximum is desired. If `a` is not a
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the maximum is computed. The default is to compute
+        the maximum of the flattened tensor.
+    out : ndarray, optional
+        Alternate output array 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 original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `max` method
+        of sub-classes of `Tensor`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    nanmax : Tensor
+        A tensor with the same shape as `a`, with the specified axis removed.
+        If `a` is a 0-d tensor, or if axis is None, a Tensor scalar is
+        returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmin :
+        The minimum value of a tensor along a given axis, ignoring any NaNs.
+    amax :
+        The maximum value of a tensor along a given axis, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two tensors, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two tensors, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amin, fmin, minimum
+
+    Notes
+    -----
+    MaxFrame uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.max.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, 2], [3, mt.nan]])
+    >>> mt.nanmax(a).execute()
+    3.0
+    >>> mt.nanmax(a, axis=0).execute()
+    array([ 3.,  2.])
+    >>> mt.nanmax(a, axis=1).execute()
+    array([ 2.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> mt.nanmax([1, 2, mt.nan, mt.NINF]).execute()
+    2.0
+    >>> mt.nanmax([1, 2, mt.nan, mt.inf]).execute()
+    inf
+
+    """
+    a = astensor(a)
+    op = TensorNanMax(axis=axis, dtype=a.dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanmean.py

@@ -0,0 +1,105 @@
+# 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 TensorNanMean(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANMEAN
+    _func_name = "nanmean"
+
+
+def nanmean(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Compute the arithmetic mean along the specified axis, ignoring NaNs.
+
+    Returns the average of the tensor 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.
+
+    For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose mean is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the means are computed. The default is to compute
+        the mean of the flattened tensor.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for inexact 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 original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `Tensor`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    m : Tensor, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned. Nan is
+        returned for slices that contain only NaNs.
+
+    See Also
+    --------
+    average : Weighted average
+    mean : Arithmetic mean taken while not ignoring NaNs
+    var, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the non-NaN elements along the axis
+    divided by the number of non-NaN 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`.  Specifying a
+    higher-precision accumulator using the `dtype` keyword can alleviate
+    this issue.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, mt.nan], [3, 4]])
+    >>> mt.nanmean(a).execute()
+    2.6666666666666665
+    >>> mt.nanmean(a, axis=0).execute()
+    array([ 2.,  4.])
+    >>> mt.nanmean(a, axis=1).execute()
+    array([ 1.,  3.5])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nanmean(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanMean(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanmin.py

@@ -0,0 +1,109 @@
+# 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 TensorNanMin(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANMIN
+    _func_name = "nanmin"
+
+
+def nanmin(a, axis=None, out=None, keepdims=None):
+    """
+    Return minimum of a tensor or minimum along an axis, ignoring any NaNs.
+    When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
+    Nan is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose minimum is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the minimum is computed. The default is to compute
+        the minimum of the flattened tensor.
+    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 original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `min` method
+        of sub-classes of `Tensor`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    nanmin : Tensor
+        An tensor with the same shape as `a`, with the specified axis
+        removed.  If `a` is a 0-d tensor, or if axis is None, a tensor
+        scalar is returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amax, fmax, maximum
+
+    Notes
+    -----
+    MaxFrame uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to mt.min.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, 2], [3, mt.nan]])
+    >>> mt.nanmin(a).execute()
+    1.0
+    >>> mt.nanmin(a, axis=0).execute()
+    array([ 1.,  2.])
+    >>> mt.nanmin(a, axis=1).execute()
+    array([ 1.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> mt.nanmin([1, 2, mt.nan, mt.inf]).execute()
+    1.0
+    >>> mt.nanmin([1, 2, mt.nan, mt.NINF]).execute()
+    -inf
+
+    """
+    a = astensor(a)
+    op = TensorNanMin(axis=axis, dtype=a.dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanprod.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 TensorReduction, TensorReductionMixin
+
+
+class TensorNanProd(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANPROD
+    _func_name = "nanprod"
+
+
+def nanprod(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Return the product of array elements over a given axis treating Not a
+    Numbers (NaNs) as ones.
+
+    One is returned for slices that are all-NaN or empty.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose product is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the product is computed. The default is to compute
+        the product of the flattened tensor.
+    dtype : data-type, optional
+        The type of the returned tensor and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    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. The casting of NaN to integer can yield
+        unexpected results.
+    keepdims : bool, optional
+        If 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 original `arr`.
+
+    Returns
+    -------
+    nanprod : Tensor
+        A new tensor holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    mt.prod : Product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.nanprod(1).execute()
+    1
+    >>> mt.nanprod([1]).execute()
+    1
+    >>> mt.nanprod([1, mt.nan]).execute()
+    1.0
+    >>> a = mt.array([[1, 2], [3, mt.nan]])
+    >>> mt.nanprod(a).execute()
+    6.0
+    >>> mt.nanprod(a, axis=0).execute()
+    array([ 3.,  2.])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nanprod(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanProd(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanstd.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 ..arithmetic.sqrt import sqrt
+from .nanvar import nanvar
+
+
+def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=None):
+    """
+    Compute the standard deviation along the specified axis, while
+    ignoring NaNs.
+
+    Returns the standard deviation, a measure of the spread of a
+    distribution, of the non-NaN tensor elements. The standard deviation is
+    computed for the flattened tensor by default, otherwise over the
+    specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of the non-NaN values.
+    axis : int, optional
+        Axis along which the standard deviation is computed. The default is
+        to compute the standard deviation of the flattened tensor.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For tensors of
+        integer type the default is float64, for tensors of float types it
+        is the same as the tensor type.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must have
+        the same shape as the expected output but the type (of the
+        calculated values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements.  By default `ddof` is zero.
+
+    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 original `a`.
+
+        If this value is anything but the default it is passed through
+        as-is to the relevant functions of the sub-classes.  If these
+        functions do not have a `keepdims` kwarg, a RuntimeError will
+        be raised.
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard
+        deviation, otherwise return a reference to the output tensor. If
+        ddof is >= the number of non-NaN elements in a slice or the slice
+        contains only NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    var, mean, std
+    nanvar, nanmean
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation is normally calculated as
+    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
+    specified, the divisor ``N - ddof`` is used instead. In standard
+    statistical practice, ``ddof=1`` provides an unbiased estimator of the
+    variance of the infinite population. ``ddof=0`` provides a maximum
+    likelihood estimate of the variance for normally distributed variables.
+    The standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute value before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* 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-accuracy accumulator using the `dtype`
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, mt.nan], [3, 4]])
+    >>> mt.nanstd(a).execute()
+    1.247219128924647
+    >>> mt.nanstd(a, axis=0).execute()
+    array([ 1.,  0.])
+    >>> mt.nanstd(a, axis=1).execute()
+    array([ 0.,  0.5])
+
+    """
+    ret = sqrt(
+        nanvar(
+            a,
+            axis=axis,
+            dtype=dtype,
+            out=out,
+            ddof=ddof,
+            keepdims=keepdims,
+        )
+    )
+    if dtype is not None and ret.dtype != dtype:
+        ret = ret.astype(dtype)
+    return ret

maxframe/tensor/reduction/nansum.py

@@ -0,0 +1,113 @@
+# 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 TensorNanSum(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANSUM
+    _func_name = "nansum"
+
+
+def nansum(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Return the sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.
+
+    Zero is returned for slices that are all-NaN or
+    empty.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose sum is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the sum is computed. The default is to compute the
+        sum of the flattened array.
+    dtype : data-type, optional
+        The type of the returned tensor and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    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. The casting of NaN to integer can yield
+        unexpected results.
+    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 original `a`.
+
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `Tensor`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    nansum : 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 array.
+
+    See Also
+    --------
+    mt.sum : Sum across tensor propagating NaNs.
+    isnan : Show which elements are NaN.
+    isfinite: Show which elements are not NaN or +/-inf.
+
+    Notes
+    -----
+    If both positive and negative infinity are present, the sum will be Not
+    A Number (NaN).
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.nansum(1).execute()
+    1
+    >>> mt.nansum([1]).execute()
+    1
+    >>> mt.nansum([1, mt.nan]).execute()
+    1.0
+    >>> a = mt.array([[1, 1], [1, mt.nan]])
+    >>> mt.nansum(a).execute()
+    3.0
+    >>> mt.nansum(a, axis=0).execute()
+    array([ 2.,  1.])
+    >>> mt.nansum([1, mt.nan, mt.inf]).execute()
+    inf
+    >>> mt.nansum([1, mt.nan, mt.NINF]).execute()
+    -inf
+    >>> mt.nansum([1, mt.nan, mt.inf, -mt.inf]).execute() # both +/- infinity present
+    nan
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nansum(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanSum(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)