maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/reduction/count.py

@@ -0,0 +1,63 @@
+# 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, ReductionCallable
+
+
+class CountReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna, numeric_only = self.kwargs["skipna"], self.kwargs["numeric_only"]
+        if value.ndim == 1:
+            return value.count()
+        return value.count(skipna=skipna, numeric_only=numeric_only)
+
+
+class DataFrameCount(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.COUNT
+    _func_name = "count"
+
+    @property
+    def is_atomic(self):
+        return True
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, numeric_only = op.skipna, op.numeric_only
+        return CountReductionCallable(
+            func_name="count", kwargs={"skipna": skipna, "numeric_only": numeric_only}
+        )
+
+
+def count_series(series, level=None, **kw):
+    method = kw.pop("method", None)
+    op = DataFrameCount(
+        level=level,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(series)
+
+
+def count_dataframe(df, axis=0, level=None, numeric_only=False, **kw):
+    method = kw.pop("method", None)
+    op = DataFrameCount(
+        axis=axis,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/cov.py

@@ -0,0 +1,166 @@
+# 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.
+
+
+def cov_dataframe(df, min_periods=None, ddof=1, numeric_only=True):
+    """
+    Compute pairwise covariance of columns, excluding NA/null values.
+
+    Compute the pairwise covariance among the series of a DataFrame.
+    The returned data frame is the `covariance matrix
+    <https://en.wikipedia.org/wiki/Covariance_matrix>`__ of the columns
+    of the DataFrame.
+
+    Both NA and null values are automatically excluded from the
+    calculation. (See the note below about bias from missing values.)
+    A threshold can be set for the minimum number of
+    observations for each value created. Comparisons with observations
+    below this threshold will be returned as ``NaN``.
+
+    This method is generally used for the analysis of time series data to
+    understand the relationship between different measures
+    across time.
+
+    Parameters
+    ----------
+    min_periods : int, optional
+        Minimum number of observations required per pair of columns
+        to have a valid result.
+
+    ddof : int, default 1
+        Delta degrees of freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+        This argument is applicable only when no ``nan`` is in the dataframe.
+
+    numeric_only : bool, default True
+        Include only `float`, `int` or `boolean` data.
+
+    Returns
+    -------
+    DataFrame
+        The covariance matrix of the series of the DataFrame.
+
+    See Also
+    --------
+    Series.cov : Compute covariance with another Series.
+    core.window.ewm.ExponentialMovingWindow.cov : Exponential weighted sample
+        covariance.
+    core.window.expanding.Expanding.cov : Expanding sample covariance.
+    core.window.rolling.Rolling.cov : Rolling sample covariance.
+
+    Notes
+    -----
+    Returns the covariance matrix of the DataFrame's time series.
+    The covariance is normalized by N-ddof.
+
+    For DataFrames that have Series that are missing data (assuming that
+    data is `missing at random
+    <https://en.wikipedia.org/wiki/Missing_data#Missing_at_random>`__)
+    the returned covariance matrix will be an unbiased estimate
+    of the variance and covariance between the member Series.
+
+    However, for many applications this estimate may not be acceptable
+    because the estimate covariance matrix is not guaranteed to be positive
+    semi-definite. This could lead to estimate correlations having
+    absolute values which are greater than one, and/or a non-invertible
+    covariance matrix. See `Estimation of covariance matrices
+    <https://en.wikipedia.org/w/index.php?title=Estimation_of_covariance_
+    matrices>`__ for more details.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([(1, 2), (0, 3), (2, 0), (1, 1)],
+    ...                   columns=['dogs', 'cats'])
+    >>> df.cov().execute()
+              dogs      cats
+    dogs  0.666667 -1.000000
+    cats -1.000000  1.666667
+
+    >>> mt.random.seed(42)
+    >>> df = md.DataFrame(mt.random.randn(1000, 5),
+    ...                   columns=['a', 'b', 'c', 'd', 'e'])
+    >>> df.cov().execute()
+              a         b         c         d         e
+    a  0.998438 -0.020161  0.059277 -0.008943  0.014144
+    b -0.020161  1.059352 -0.008543 -0.024738  0.009826
+    c  0.059277 -0.008543  1.010670 -0.001486 -0.000271
+    d -0.008943 -0.024738 -0.001486  0.921297 -0.013692
+    e  0.014144  0.009826 -0.000271 -0.013692  0.977795
+
+    **Minimum number of periods**
+
+    This method also supports an optional ``min_periods`` keyword
+    that specifies the required minimum number of non-NA observations for
+    each column pair in order to have a valid result:
+
+    >>> mt.random.seed(42)
+    >>> df = md.DataFrame(mt.random.randn(20, 3),
+    ...                   columns=['a', 'b', 'c'])
+    >>> df.loc[df.index[:5], 'a'] = mt.nan
+    >>> df.loc[df.index[5:10], 'b'] = mt.nan
+    >>> df.cov(min_periods=12).execute()
+              a         b         c
+    a  0.316741       NaN -0.150812
+    b       NaN  1.248003  0.191417
+    c -0.150812  0.191417  0.895202
+    """
+    from ..statistics.corr import DataFrameCorr
+
+    if not numeric_only:
+        raise NotImplementedError("numeric_only==True not supported")
+    op = DataFrameCorr(method="cov", min_periods=min_periods, ddof=ddof)
+    return op(df)
+
+
+def cov_series(series, other, min_periods=None, ddof=1):
+    """
+    Compute covariance with Series, excluding missing values.
+
+    The two `Series` objects are not required to be the same length and
+    will be aligned internally before the covariance is calculated.
+
+    Parameters
+    ----------
+    other : Series
+        Series with which to compute the covariance.
+    min_periods : int, optional
+        Minimum number of observations needed to have a valid result.
+    ddof : int, default 1
+        Delta degrees of freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+
+    Returns
+    -------
+    float
+        Covariance between Series and other normalized by N-1
+        (unbiased estimator).
+
+    See Also
+    --------
+    DataFrame.cov : Compute pairwise covariance of columns.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s1 = md.Series([0.90010907, 0.13484424, 0.62036035])
+    >>> s2 = md.Series([0.12528585, 0.26962463, 0.51111198])
+    >>> s1.cov(s2).execute()
+    -0.01685762652715874
+    """
+    from ..statistics.corr import DataFrameCorr
+
+    op = DataFrameCorr(other=other, method="cov", min_periods=min_periods, ddof=ddof)
+    return op(series)

maxframe/dataframe/reduction/cummax.py

@@ -0,0 +1,30 @@
+# 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 DataFrameCumReduction, DataFrameCumReductionMixin
+
+
+class DataFrameCummax(DataFrameCumReduction, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMMAX
+    _func_name = "cummax"
+
+
+def cummax(df, axis=None, skipna=True):
+    op = DataFrameCummax(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cummin.py

@@ -0,0 +1,30 @@
+# 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 DataFrameCumReduction, DataFrameCumReductionMixin
+
+
+class DataFrameCummin(DataFrameCumReduction, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMMIN
+    _func_name = "cummin"
+
+
+def cummin(df, axis=None, skipna=True):
+    op = DataFrameCummin(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cumprod.py

@@ -0,0 +1,30 @@
+# 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 DataFrameCumReduction, DataFrameCumReductionMixin
+
+
+class DataFrameCumprod(DataFrameCumReduction, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMPROD
+    _func_name = "cumprod"
+
+
+def cumprod(df, axis=None, skipna=True):
+    op = DataFrameCumprod(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cumsum.py

@@ -0,0 +1,30 @@
+# 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 DataFrameCumReduction, DataFrameCumReductionMixin
+
+
+class DataFrameCumsum(DataFrameCumReduction, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMSUM
+    _func_name = "cumsum"
+
+
+def cumsum(df, axis=None, skipna=True):
+    op = DataFrameCumsum(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/custom_reduction.py

@@ -0,0 +1,42 @@
+# 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 AnyField
+from .core import DataFrameReduction, DataFrameReductionMixin
+
+
+class DataFrameCustomReduction(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.CUSTOM_REDUCTION
+    _func_name = "custom_reduction"
+
+    custom_reduction = AnyField("custom_reduction")
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        return dict()
+
+
+def build_custom_reduction_result(df, custom_reduction_obj, method=None):
+    output_type = OutputType.series if df.ndim == 2 else OutputType.scalar
+    op = DataFrameCustomReduction(
+        custom_reduction=custom_reduction_obj,
+        output_types=[output_type],
+        method=method,
+    )
+    return op(df)

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)