Merge remote-tracking branch 'upstream/main' into holiday-daysofweek-value-error

Author: sharkipelago

doc/source/whatsnew/v3.0.0.rst

@@ -64,6 +64,7 @@ Other enhancements
 - :meth:`Series.nlargest` uses a 'stable' sort internally and will preserve original ordering.
 - :class:`ArrowDtype` now supports ``pyarrow.JsonType`` (:issue:`60958`)
 - :class:`DataFrameGroupBy` and :class:`SeriesGroupBy` methods ``sum``, ``mean``, ``median``, ``prod``, ``min``, ``max``, ``std``, ``var`` and ``sem`` now accept ``skipna`` parameter (:issue:`15675`)
+- :class:`Easter` has gained a new constructor argument ``method`` which specifies the method used to calculate Easter — for example, Orthodox Easter (:issue:`61665`)
 - :class:`Holiday` has gained the constructor argument and field ``exclude_dates`` to exclude specific datetimes from a custom holiday calendar (:issue:`54382`)
 - :class:`Holiday` constructor argument ``days_of_week`` will  raise a ``ValueError`` when type is something other than ``None`` or ``tuple``
 - :class:`Rolling` and :class:`Expanding` now support ``nunique`` (:issue:`26958`)
@@ -717,6 +718,7 @@ Numeric
 - Bug in :meth:`DataFrame.cov` raises a ``TypeError`` instead of returning potentially incorrect results or other errors (:issue:`53115`)
 - Bug in :meth:`DataFrame.quantile` where the column type was not preserved when ``numeric_only=True`` with a list-like ``q`` produced an empty result (:issue:`59035`)
 - Bug in :meth:`Series.dot` returning ``object`` dtype for :class:`ArrowDtype` and nullable-dtype data (:issue:`61375`)
+- Bug in :meth:`Series.std` and :meth:`Series.var` when using complex-valued data (:issue:`61645`)
 - Bug in ``np.matmul`` with :class:`Index` inputs raising a ``TypeError`` (:issue:`57079`)
 
 Conversion

pandas/_libs/tslibs/offsets.pyi

@@ -230,7 +230,13 @@ class FY5253Quarter(FY5253Mixin):
         variation: Literal["nearest", "last"] = ...,
     ) -> None: ...
 
-class Easter(SingleConstructorOffset): ...
+class Easter(SingleConstructorOffset):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        method: int = ...,
+    ) -> None: ...
 
 class _CustomBusinessMonth(BusinessMixin):
     def __init__(

pandas/_libs/tslibs/offsets.pyx

@@ -4520,6 +4520,12 @@ cdef class Easter(SingleConstructorOffset):
         The number of years represented.
     normalize : bool, default False
         Normalize start/end dates to midnight before generating date range.
+    method : int, default 3
+        The method used to calculate the date of Easter. Valid options are:
+        - 1 (EASTER_JULIAN): Original calculation in Julian calendar
+        - 2 (EASTER_ORTHODOX): Original method, date converted to Gregorian calendar
+        - 3 (EASTER_WESTERN): Revised method, in Gregorian calendar
+        These constants are defined in the `dateutil.easter` module.
 
     See Also
     --------
@@ -4532,15 +4538,32 @@ cdef class Easter(SingleConstructorOffset):
     Timestamp('2022-04-17 00:00:00')
     """
 
+    _attributes = tuple(["n", "normalize", "method"])
+
+    cdef readonly:
+        int method
+
+    from dateutil.easter import EASTER_WESTERN
+
+    def __init__(self, n=1, normalize=False, method=EASTER_WESTERN):
+        BaseOffset.__init__(self, n, normalize)
+
+        self.method = method
+
+        if method < 1 or method > 3:
+            raise ValueError(f"Method must be 1<=method<=3, got {method}")
+
     cpdef __setstate__(self, state):
+        from dateutil.easter import EASTER_WESTERN
         self.n = state.pop("n")
         self.normalize = state.pop("normalize")
+        self.method = state.pop("method", EASTER_WESTERN)
 
     @apply_wraps
     def _apply(self, other: datetime) -> datetime:
         from dateutil.easter import easter
 
-        current_easter = easter(other.year)
+        current_easter = easter(other.year, method=self.method)
         current_easter = datetime(
             current_easter.year, current_easter.month, current_easter.day
         )
@@ -4555,7 +4578,7 @@ cdef class Easter(SingleConstructorOffset):
 
         # NOTE: easter returns a datetime.date so we have to convert to type of
         # other
-        new = easter(other.year + n)
+        new = easter(other.year + n, method=self.method)
         new = datetime(
             new.year,
             new.month,
@@ -4573,7 +4596,7 @@ cdef class Easter(SingleConstructorOffset):
 
         from dateutil.easter import easter
 
-        return date(dt.year, dt.month, dt.day) == easter(dt.year)
+        return date(dt.year, dt.month, dt.day) == easter(dt.year, method=self.method)
 
 
 # ----------------------------------------------------------------------

pandas/core/nanops.py

@@ -1014,7 +1014,11 @@ def nanvar(
     avg = _ensure_numeric(values.sum(axis=axis, dtype=np.float64)) / count
     if axis is not None:
         avg = np.expand_dims(avg, axis)
-    sqr = _ensure_numeric((avg - values) ** 2)
+    if values.dtype.kind == "c":
+        # Need to use absolute value for complex numbers.
+        sqr = _ensure_numeric(abs(avg - values) ** 2)
+    else:
+        sqr = _ensure_numeric((avg - values) ** 2)
     if mask is not None:
         np.putmask(sqr, mask, 0)
     result = sqr.sum(axis=axis, dtype=np.float64) / d

pandas/tests/reductions/test_reductions.py

@@ -780,6 +780,12 @@ def test_var_masked_array(self, ddof, exp):
         assert result == result_numpy_dtype
         assert result == exp
 
+    def test_var_complex_array(self):
+        # GH#61645
+        ser = Series([-1j, 0j, 1j], dtype=complex)
+        assert ser.var(ddof=1) == 1.0
+        assert ser.std(ddof=1) == 1.0
+
     @pytest.mark.parametrize("dtype", ("m8[ns]", "M8[ns]", "M8[ns, UTC]"))
     def test_empty_timeseries_reductions_return_nat(self, dtype, skipna):
         # covers GH#11245

pandas/tests/tseries/offsets/test_easter.py

@@ -7,6 +7,10 @@
 
 from datetime import datetime
 
+from dateutil.easter import (
+    EASTER_ORTHODOX,
+    EASTER_WESTERN,
+)
 import pytest
 
 from pandas.tests.tseries.offsets.common import assert_offset_equal
@@ -32,3 +36,115 @@ class TestEaster:
     )
     def test_offset(self, offset, date, expected):
         assert_offset_equal(offset, date, expected)
+
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (Easter(method=EASTER_WESTERN), datetime(2010, 1, 1), datetime(2010, 4, 4)),
+            (
+                Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 5),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 1, 1),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2012, 4, 8),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2011, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 5),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(2, method=EASTER_WESTERN),
+                datetime(2011, 1, 1),
+                datetime(2009, 4, 12),
+            ),
+            (
+                -Easter(method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2009, 4, 12),
+            ),
+            (
+                -Easter(2, method=EASTER_WESTERN),
+                datetime(2010, 4, 4),
+                datetime(2008, 3, 23),
+            ),
+        ],
+    )
+    def test_western_easter_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)
+
+    @pytest.mark.parametrize(
+        "offset,date,expected",
+        [
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 5),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 1, 1),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2011, 4, 24),
+            ),
+            (
+                Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2012, 4, 15),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2011, 1, 1),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 5),
+                datetime(2010, 4, 4),
+            ),
+            (
+                -Easter(2, method=EASTER_ORTHODOX),
+                datetime(2011, 1, 1),
+                datetime(2009, 4, 19),
+            ),
+            (
+                -Easter(method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2009, 4, 19),
+            ),
+            (
+                -Easter(2, method=EASTER_ORTHODOX),
+                datetime(2010, 4, 4),
+                datetime(2008, 4, 27),
+            ),
+        ],
+    )
+    def test_orthodox_easter_offset(self, offset, date, expected):
+        assert_offset_equal(offset, date, expected)

pandas/tests/tseries/offsets/test_offsets.py

@@ -239,7 +239,7 @@ def test_offset_freqstr(self, offset_types):
         offset = _create_offset(offset_types)
 
         freqstr = offset.freqstr
-        if freqstr not in ("<Easter>", "<DateOffset: days=1>", "LWOM-SAT"):
+        if freqstr not in ("<Easter: method=3>", "<DateOffset: days=1>", "LWOM-SAT"):
             code = _get_offset(freqstr)
             assert offset.rule_code == code
 

web/pandas/community/benchmarks.md

@@ -30,7 +30,7 @@ The [asv-runner](https://github.com/pandas-dev/asv-runner/) repository automatic
 for every (or almost every) commit to the `main` branch. It is run on GitHub actions.
 See the linked repository for more details. The results are available at:
 
-https://pandas-dev.github.io/asv-runner/
+[https://pandas-dev.github.io/asv-runner/](https://pandas-dev.github.io/asv-runner/)
 
 ## Community benchmarks