maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/reduction/mode.py

@@ -0,0 +1,190 @@
+# 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.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([2, 4, 2, 2, 4, None])
+    >>> s.mode().execute()
+    0    2.0
+    dtype: float64
+
+    More than one mode:
+
+    >>> s = md.Series([2, 4, 8, 2, 4, None])
+    >>> s.mode().execute()
+    0    2.0
+    1    4.0
+    dtype: float64
+
+    With and without considering null value:
+
+    >>> s = md.Series([2, 4, None, None, 4, None])
+    >>> s.mode(dropna=False).execute()
+    0   NaN
+    dtype: float64
+    >>> s = md.Series([2, 4, None, None, 4, None])
+    >>> s.mode().execute()
+    0    4.0
+    dtype: float64
+    """
+    op = DataFrameMode(
+        axis=0,
+        dropna=dropna,
+        combine_size=combine_size,
+        output_types=[OutputType.series],
+    )
+    return op(series)

maxframe/dataframe/reduction/nunique.py

@@ -0,0 +1,149 @@
+# 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.
+
+try:
+    import pyarrow as pa
+except ImportError:  # pragma: no cover
+    pa = None
+
+from ... import opcodes
+from ...config import options
+from ...core import OutputType
+from ...serialization.serializables import BoolField, StringField
+from ...utils import lazy_import
+from ..utils import validate_dtype_backend
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+cudf = lazy_import("cudf")
+
+
+class DataFrameNunique(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.NUNIQUE
+    _func_name = "nunique"
+
+    dropna = BoolField("dropna", default=None)
+    dtype_backend = StringField(
+        "dtype_backend", on_deserialize=validate_dtype_backend, default=None
+    )
+
+    def __init__(self, dtype_backend=None, **kw):
+        dtype_backend = validate_dtype_backend(dtype_backend)
+        super().__init__(dtype_backend=dtype_backend, **kw)
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        args = dict(dropna=self.dropna)
+        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(dropna=op.dropna)
+        kw = {k: v for k, v in kw.items() if v is not None}
+        return ReductionCallable(func_name=func_name, kwargs=kw)
+
+
+def nunique_dataframe(df, axis=0, dropna=True):
+    """
+    Count distinct observations over requested axis.
+
+    Return Series with number of distinct observations. Can ignore NaN
+    values.
+
+    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.
+    dropna : bool, default True
+        Don't include NaN in the counts.
+
+    Returns
+    -------
+    Series
+
+    See Also
+    --------
+    Series.nunique: Method nunique for Series.
+    DataFrame.count: Count non-NA cells for each column or row.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 2, 3], 'B': [1, 1, 1]})
+    >>> df.nunique().execute()
+    A    3
+    B    1
+    dtype: int64
+
+    >>> df.nunique(axis=1).execute()
+    0    1
+    1    2
+    2    2
+    dtype: int64
+    """
+    op = DataFrameNunique(
+        axis=axis,
+        dropna=dropna,
+        output_types=[OutputType.series],
+    )
+    return op(df)
+
+
+def nunique_series(series, dropna=True):
+    """
+    Return number of unique elements in the object.
+
+    Excludes NA values by default.
+
+    Parameters
+    ----------
+    dropna : bool, default True
+        Don't include NaN in the count.
+
+    Returns
+    -------
+    int
+
+    See Also
+    --------
+    DataFrame.nunique: Method nunique for DataFrame.
+    Series.count: Count non-NA/null observations in the Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 3, 5, 7, 7])
+    >>> s.execute()
+    0    1
+    1    3
+    2    5
+    3    7
+    4    7
+    dtype: int64
+
+    >>> s.nunique().execute()
+    4
+    """
+    op = DataFrameNunique(
+        dropna=dropna,
+        output_types=[OutputType.scalar],
+        dtype_backend=options.dataframe.dtype_backend,
+    )
+    return op(series)

maxframe/dataframe/reduction/prod.py

@@ -0,0 +1,81 @@
+# 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
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class ProdReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna, min_count = self.kwargs["skipna"], self.kwargs["min_count"]
+        if min_count == 0:
+            return value.prod(skipna=skipna)
+        else:
+            return where_function(
+                value.count() >= min_count, value.prod(skipna=skipna), np.nan
+            )
+
+
+class DataFrameProd(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.PROD
+    _func_name = "prod"
+
+    @property
+    def is_atomic(self):
+        return self.min_count == 0
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, min_count = op.skipna, op.min_count
+        return ProdReductionCallable(
+            func_name="prod", kwargs=dict(skipna=skipna, min_count=min_count)
+        )
+
+
+def prod_series(df, axis=None, skipna=True, level=None, min_count=0, method=None):
+    op = DataFrameProd(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def prod_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    min_count=0,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameProd(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/reduction_size.py

@@ -0,0 +1,36 @@
+# 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 .core import DataFrameReduction, DataFrameReductionMixin
+
+
+class DataFrameSize(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.REDUCTION_SIZE
+    _func_name = "size"
+
+    @property
+    def is_atomic(self):
+        return True
+
+
+def size_series(df):
+    op = DataFrameSize(output_types=[OutputType.scalar])
+    return op(df)
+
+
+def size_dataframe(df):
+    op = DataFrameSize(output_types=[OutputType.series])
+    return op(df)

maxframe/dataframe/reduction/sem.py

@@ -0,0 +1,73 @@
+# 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 ...serialization.serializables import Int32Field
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class SemReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna, ddof = self.kwargs["skipna"], self.kwargs["ddof"]
+        var = value.var(skipna=skipna, ddof=ddof)
+        cnt = value.count()
+        return (var / cnt) ** 0.5
+
+
+class DataFrameSem(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.SEM
+    _func_name = "sem"
+
+    ddof = Int32Field("ddof", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameSem"):
+        skipna, ddof = op.skipna, op.ddof
+        return SemReductionCallable(
+            func_name="sem", kwargs={"skipna": skipna, "ddof": ddof}
+        )
+
+
+def sem_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):
+    op = DataFrameSem(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(series)
+
+
+def sem_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    ddof=1,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameSem(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/skew.py

@@ -0,0 +1,93 @@
+# 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 ENTITY_TYPE, OutputType
+from ...serialization.serializables import BoolField
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class SkewReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna, bias = self.kwargs["skipna"], self.kwargs["bias"]
+        cnt = value.count()
+        mean = value.mean(skipna=skipna)
+        divided = (
+            (value**3).mean(skipna=skipna)
+            - 3 * (value**2).mean(skipna=skipna) * mean
+            + 2 * mean**3
+        )
+        var = value.var(skipna=skipna, ddof=0)
+        if isinstance(var, ENTITY_TYPE) or var > 0:
+            val = where_function(var > 0, divided / var**1.5, np.nan)
+        else:
+            val = np.nan
+        if not bias:
+            val = where_function(
+                (var > 0) & (cnt > 2),
+                val * ((cnt * (cnt - 1)) ** 0.5 / (cnt - 2)),
+                np.nan,
+            )
+        return val
+
+
+class DataFrameSkew(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.SKEW
+    _func_name = "skew"
+
+    bias = BoolField("bias", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameSkew"):
+        skipna, bias = op.skipna, op.bias
+        return SkewReductionCallable(
+            func_name="skew", kwargs=dict(skipna=skipna, bias=bias)
+        )
+
+
+def skew_series(df, axis=None, skipna=True, level=None, bias=False, method=None):
+    op = DataFrameSkew(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        bias=bias,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def skew_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    bias=False,
+    method=None,
+):
+    op = DataFrameSkew(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        bias=bias,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/std.py

@@ -0,0 +1,53 @@
+# 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 ...tensor.arithmetic import sqrt
+from .var import var_dataframe, var_series
+
+
+def std_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    ddof=1,
+    numeric_only=None,
+    method=None,
+):
+    ret = sqrt(
+        var_dataframe(
+            df,
+            axis=axis,
+            skipna=skipna,
+            level=level,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            method=method,
+        )
+    )
+    return ret
+
+
+def std_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):
+    ret = sqrt(
+        var_series(
+            series,
+            axis=axis,
+            skipna=skipna,
+            level=level,
+            ddof=ddof,
+            method=method,
+        )
+    )
+    return ret