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

maxframe/dataframe/reduction/idxmax.py

@@ -0,0 +1,185 @@
+# 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 ...core import OutputType
+from ..utils import validate_axis
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class DataFrameIdxMax(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.IDXMAX
+    _func_name = "idxmax"
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        args = dict(skipna=self.skipna)
+        if self.inputs and self.inputs[0].ndim > 1:
+            args["axis"] = axis
+        return {k: v for k, v in args.items() if v is not None}
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        func_name = getattr(op, "_func_name")
+        kw = dict(skipna=op.skipna)
+        kw = {k: v for k, v in kw.items() if v is not None}
+        return ReductionCallable(func_name=func_name, kwargs=kw)
+
+
+def idxmax_dataframe(df, axis=0, skipna=True):
+    """
+    Return index of first occurrence of maximum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+
+    Returns
+    -------
+    Series
+        Indexes of maxima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmax : Return index of the maximum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmax``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'consumption': [10.51, 103.11, 55.48],
+    ...                    'co2_emissions': [37.2, 19.66, 1712]},
+    ...                    index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df.execute()
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the maximum value in each column.
+
+    >>> df.idxmax().execute()
+    consumption     Wheat Products
+    co2_emissions             Beef
+    dtype: object
+
+    To return the index for the maximum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmax(axis="columns").execute()
+    Pork              co2_emissions
+    Wheat Products     consumption
+    Beef              co2_emissions
+    dtype: object
+    """
+    axis = validate_axis(axis, df)
+    op = DataFrameIdxMax(
+        axis=axis,
+        skipna=skipna,
+        output_types=[OutputType.series],
+    )
+    return op(df)
+
+
+def idxmax_series(series, axis=0, skipna=True):
+    """
+    Return the row label of the maximum value.
+
+    If multiple values equal the maximum, the first row label with that
+    value is returned.
+
+    Parameters
+    ----------
+    axis : int, default 0
+        For compatibility with DataFrame.idxmax. Redundant for application
+        on Series.
+    skipna : bool, default True
+        Exclude NA/null values. If the entire Series is NA, the result
+        will be NA.
+    *args, **kwargs
+        Additional arguments and keywords have no effect but might be
+        accepted for compatibility with NumPy.
+
+    Returns
+    -------
+    Index
+        Label of the maximum value.
+
+    Raises
+    ------
+    ValueError
+        If the Series is empty.
+
+    See Also
+    --------
+    numpy.argmax : Return indices of the maximum values
+        along the given axis.
+    DataFrame.idxmax : Return index of first occurrence of maximum
+        over requested axis.
+    Series.idxmin : Return index *label* of the first occurrence
+        of minimum of values.
+
+    Notes
+    -----
+    This method is the Series version of ``ndarray.argmax``. This method
+    returns the label of the maximum, while ``ndarray.argmax`` returns
+    the position. To get the position, use ``series.values.argmax()``.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(data=[1, None, 4, 3, 4],
+    ...               index=['A', 'B', 'C', 'D', 'E'])
+    >>> s.execute()
+    A    1.0
+    B    NaN
+    C    4.0
+    D    3.0
+    E    4.0
+    dtype: float64
+
+    >>> s.idxmax().execute()
+    'C'
+
+    If `skipna` is False and there is an NA value in the data,
+    the function returns ``nan``.
+
+    >>> s.idxmax(skipna=False).execute()
+    nan
+    """
+    validate_axis(axis, series)
+    op = DataFrameIdxMax(
+        dropna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(series)

maxframe/dataframe/reduction/idxmin.py

@@ -0,0 +1,185 @@
+# 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 ...core import OutputType
+from ..utils import validate_axis
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class DataFrameIdxMin(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.IDXMIN
+    _func_name = "idxmin"
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        args = dict(skipna=self.skipna)
+        if self.inputs and self.inputs[0].ndim > 1:
+            args["axis"] = axis
+        return {k: v for k, v in args.items() if v is not None}
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        func_name = getattr(op, "_func_name")
+        kw = dict(skipna=op.skipna)
+        kw = {k: v for k, v in kw.items() if v is not None}
+        return ReductionCallable(func_name=func_name, kwargs=kw)
+
+
+def idxmin_dataframe(df, axis=0, skipna=True):
+    """
+    Return index of first occurrence of minimum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+
+    Returns
+    -------
+    Series
+        Indexes of minima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmin : Return index of the minimum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmin``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'consumption': [10.51, 103.11, 55.48],
+    ...                    'co2_emissions': [37.2, 19.66, 1712]},
+    ...                    index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df.execute()
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the minimum value in each column.
+
+    >>> df.idxmin().execute()
+    consumption                Pork
+    co2_emissions    Wheat Products
+    dtype: object
+
+    To return the index for the minimum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmin(axis="columns").execute()
+    Pork                consumption
+    Wheat Products    co2_emissions
+    Beef                consumption
+    dtype: object
+    """
+    axis = validate_axis(axis, df)
+    op = DataFrameIdxMin(
+        axis=axis,
+        skipna=skipna,
+        output_types=[OutputType.series],
+    )
+    return op(df)
+
+
+def idxmin_series(series, axis=0, skipna=True):
+    """
+    Return the row label of the minimum value.
+
+    If multiple values equal the minimum, the first row label with that
+    value is returned.
+
+    Parameters
+    ----------
+    axis : int, default 0
+        For compatibility with DataFrame.idxmin. Redundant for application
+        on Series.
+    skipna : bool, default True
+        Exclude NA/null values. If the entire Series is NA, the result
+        will be NA.
+    *args, **kwargs
+        Additional arguments and keywords have no effect but might be
+        accepted for compatibility with NumPy.
+
+    Returns
+    -------
+    Index
+        Label of the minimum value.
+
+    Raises
+    ------
+    ValueError
+        If the Series is empty.
+
+    See Also
+    --------
+    numpy.argmin : Return indices of the minimum values
+        along the given axis.
+    DataFrame.idxmin : Return index of first occurrence of minimum
+        over requested axis.
+    Series.idxmin : Return index *label* of the first occurrence
+        of minimum of values.
+
+    Notes
+    -----
+    This method is the Series version of ``ndarray.argmin``. This method
+    returns the label of the minimum, while ``ndarray.argmin`` returns
+    the position. To get the position, use ``series.values.argmin()``.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(data=[1, None, 4, 3, 4],
+    ...               index=['A', 'B', 'C', 'D', 'E'])
+    >>> s.execute()
+    A    1.0
+    B    NaN
+    C    4.0
+    D    3.0
+    E    4.0
+    dtype: float64
+
+    >>> s.idxmin().execute()
+    'C'
+
+    If `skipna` is False and there is an NA value in the data,
+    the function returns ``nan``.
+
+    >>> s.idxmin(skipna=False).execute()
+    nan
+    """
+    validate_axis(axis, series)
+    op = DataFrameIdxMin(
+        dropna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(series)

maxframe/dataframe/reduction/kurtosis.py

@@ -17,10 +17,42 @@ import numpy as np
 from ... import opcodes
 from ...core import ENTITY_TYPE, OutputType
 from ...serialization.serializables import BoolField
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameKurtosis(DataFrameReductionOperator, DataFrameReductionMixin):
+class KurtosisReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna = self.kwargs["skipna"]
+        bias = self.kwargs["bias"]
+        fisher = self.kwargs["fisher"]
+
+        cnt = value.count()
+        mean = value.mean(skipna=skipna)
+        divided = (
+            (value**4).mean(skipna=skipna)
+            - 4 * (value**3).mean(skipna=skipna) * mean
+            + 6 * (value**2).mean(skipna=skipna) * mean**2
+            - 3 * mean**4
+        )
+        var = value.var(skipna=skipna, ddof=0)
+        if isinstance(var, ENTITY_TYPE) or var > 0:
+            val = where_function(var > 0, divided / var**2, np.nan)
+        else:
+            val = np.nan
+        if not bias:
+            val = where_function(
+                (var > 0) & (cnt > 3),
+                (val * (cnt**2 - 1) - 3 * (cnt - 1) ** 2) / (cnt - 2) / (cnt - 3),
+                np.nan,
+            )
+        if not fisher:
+            val += 3
+        return val
+
+
+class DataFrameKurtosis(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.KURTOSIS
     _func_name = "kurt"
 
@@ -29,35 +61,10 @@ class DataFrameKurtosis(DataFrameReductionOperator, DataFrameReductionMixin):
 
     @classmethod
     def get_reduction_callable(cls, op):
-        from .aggregation import where_function
-
         skipna, bias, fisher = op.skipna, op.bias, op.fisher
-
-        def kurt(x):
-            cnt = x.count()
-            mean = x.mean(skipna=skipna)
-            divided = (
-                (x**4).mean(skipna=skipna)
-                - 4 * (x**3).mean(skipna=skipna) * mean
-                + 6 * (x**2).mean(skipna=skipna) * mean**2
-                - 3 * mean**4
-            )
-            var = x.var(skipna=skipna, ddof=0)
-            if isinstance(var, ENTITY_TYPE) or var > 0:
-                val = where_function(var > 0, divided / var**2, np.nan)
-            else:
-                val = np.nan
-            if not bias:
-                val = where_function(
-                    (var > 0) & (cnt > 3),
-                    (val * (cnt**2 - 1) - 3 * (cnt - 1) ** 2) / (cnt - 2) / (cnt - 3),
-                    np.nan,
-                )
-            if not fisher:
-                val += 3
-            return val
-
-        return kurt
+        return KurtosisReductionCallable(
+            func_name="kurt", kwargs=dict(skipna=skipna, bias=bias, fisher=fisher)
+        )
 
 
 def kurt_series(

maxframe/dataframe/reduction/max.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMax(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMax(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MAX
     _func_name = "max"
 

maxframe/dataframe/reduction/mean.py

@@ -14,21 +14,23 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameMean(DataFrameReductionOperator, DataFrameReductionMixin):
+class MeanReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna = self.kwargs["skipna"]
+        return value.sum(skipna=skipna) / value.count()
+
+
+class DataFrameMean(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MEAN
     _func_name = "mean"
 
     @classmethod
     def get_reduction_callable(cls, op):
         skipna = op.skipna
-
-        def mean(x):
-            return x.sum(skipna=skipna) / x.count()
-
-        return mean
+        return MeanReductionCallable(func_name="mean", kwargs=dict(skipna=skipna))
 
 
 def mean_series(df, axis=None, skipna=True, level=None, method=None):

maxframe/dataframe/reduction/median.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMedian(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMedian(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MEDIAN
     _func_name = "median"
 

maxframe/dataframe/reduction/min.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMin(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMin(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MIN
     _func_name = "min"
 

maxframe/dataframe/reduction/mode.py

@@ -0,0 +1,144 @@
+# 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 OutputType, get_output_types
+from ...serialization.serializables import BoolField, Int32Field
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameMode(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.MODE
+
+    axis = Int32Field("axis", default=None)
+    numeric_only = BoolField("numeric_only", default=False)
+    dropna = BoolField("dropna", default=True)
+    combine_size = Int32Field("combine_size", default=None)
+
+    def __call__(self, in_obj):
+        self._output_types = get_output_types(in_obj)
+        params = in_obj.params
+        shape = list(in_obj.shape)
+        shape[self.axis] = np.nan
+        params["shape"] = tuple(shape)
+
+        if self.axis == 0:
+            pd_idx = in_obj.index_value.to_pandas()[:0]
+            params["index_value"] = parse_index(pd_idx)
+        else:
+            pd_idx = in_obj.columns_value.to_pandas()[:0]
+            params["columns_value"] = parse_index(pd_idx)
+            params["dtypes"] = None
+        return self.new_tileable([in_obj], **params)
+
+
+def mode_dataframe(df, axis=0, numeric_only=False, dropna=True, combine_size=None):
+    """
+    Get the mode(s) of each element along the selected axis.
+    The mode of a set of values is the value that appears most often.
+    It can be multiple values.
+    Parameters
+    ----------
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to iterate over while searching for the mode:
+        * 0 or 'index' : get mode of each column
+        * 1 or 'columns' : get mode of each row.
+    numeric_only : bool, default False
+        If True, only apply to numeric columns.
+    dropna : bool, default True
+        Don't consider counts of NaN/NaT.
+    Returns
+    -------
+    DataFrame
+        The modes of each column or row.
+    See Also
+    --------
+    Series.mode : Return the highest frequency value in a Series.
+    Series.value_counts : Return the counts of values in a Series.
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([('bird', 2, 2),
+    ...                    ('mammal', 4, mt.nan),
+    ...                    ('arthropod', 8, 0),
+    ...                    ('bird', 2, mt.nan)],
+    ...                   index=('falcon', 'horse', 'spider', 'ostrich'),
+    ...                   columns=('species', 'legs', 'wings'))
+    >>> df.execute()
+               species  legs  wings
+    falcon        bird     2    2.0
+    horse       mammal     4    NaN
+    spider   arthropod     8    0.0
+    ostrich       bird     2    NaN
+    By default, missing values are not considered, and the mode of wings
+    are both 0 and 2. Because the resulting DataFrame has two rows,
+    the second row of ``species`` and ``legs`` contains ``NaN``.
+    >>> df.mode().execute()
+      species  legs  wings
+    0    bird   2.0    0.0
+    1     NaN   NaN    2.0
+    Setting ``dropna=False`` ``NaN`` values are considered and they can be
+    the mode (like for wings).
+    >>> df.mode(dropna=False).execute()
+      species  legs  wings
+    0    bird     2    NaN
+    Setting ``numeric_only=True``, only the mode of numeric columns is
+    computed, and columns of other types are ignored.
+    >>> df.mode(numeric_only=True).execute()
+       legs  wings
+    0   2.0    0.0
+    1   NaN    2.0
+    To compute the mode over columns and not rows, use the axis parameter:
+    >>> df.mode(axis='columns', numeric_only=True).execute()
+               0    1
+    falcon   2.0  NaN
+    horse    4.0  NaN
+    spider   0.0  8.0
+    ostrich  2.0  NaN
+    """
+    op = DataFrameMode(
+        axis=validate_axis(axis),
+        numeric_only=numeric_only,
+        dropna=dropna,
+        combine_size=combine_size,
+        output_types=[OutputType.dataframe],
+    )
+    return op(df)
+
+
+def mode_series(series, dropna=True, combine_size=None):
+    """
+    Return the mode(s) of the Series.
+    The mode is the value that appears most often. There can be multiple modes.
+    Always returns Series even if only one value is returned.
+    Parameters
+    ----------
+    dropna : bool, default True
+        Don't consider counts of NaN/NaT.
+    Returns
+    -------
+    Series
+        Modes of the Series in sorted order.
+    """
+    op = DataFrameMode(
+        axis=0,
+        dropna=dropna,
+        combine_size=combine_size,
+        output_types=[OutputType.series],
+    )
+    return op(series)