Skip to content
Open
81 changes: 23 additions & 58 deletions Lib/_pydatetime.py
Original file line number Diff line number Diff line change
Expand Up @@ -90,67 +90,32 @@ def _ymd2ord(year, month, day):
# pasting together 25 4-year cycles.
assert _DI100Y == 25 * _DI4Y - 1

def _ord2ymd(n):
def _ord2ymd(ordinal):
"ordinal -> (year, month, day), considering 01-Jan-0001 as day 1."

# n is a 1-based index, starting at 1-Jan-1. The pattern of leap years
# repeats exactly every 400 years. The basic strategy is to find the
# closest 400-year boundary at or before n, then work with the offset
# from that boundary to n. Life is much clearer if we subtract 1 from
# n first -- then the values of n at 400-year boundaries are exactly
# those divisible by _DI400Y:
# Neri and Schneider's algorithm, https://doi.org/10.1002/spe.3172.
# ord_to_ymd() in Modules/_datetimemodule.c does the same steps.
#
# D M Y n n-1
# -- --- ---- ---------- ----------------
# 31 Dec -400 -_DI400Y -_DI400Y -1
# 1 Jan -399 -_DI400Y +1 -_DI400Y 400-year boundary
# ...
# 30 Dec 000 -1 -2
# 31 Dec 000 0 -1
# 1 Jan 001 1 0 400-year boundary
# 2 Jan 001 2 1
# 3 Jan 001 3 2
# ...
# 31 Dec 400 _DI400Y _DI400Y -1
# 1 Jan 401 _DI400Y +1 _DI400Y 400-year boundary
n -= 1
n400, n = divmod(n, _DI400Y)
year = n400 * 400 + 1 # ..., -399, 1, 401, ...

# Now n is the (non-negative) offset, in days, from January 1 of year, to
# the desired date. Now compute how many 100-year cycles precede n.
# Note that it's possible for n100 to equal 4! In that case 4 full
# 100-year cycles precede the desired day, which implies the desired
# day is December 31 at the end of a 400-year cycle.
n100, n = divmod(n, _DI100Y)

# Now compute how many 4-year cycles precede it.
n4, n = divmod(n, _DI4Y)

# And now how many single years. Again n1 can be 4, and again meaning
# that the desired day is December 31 at the end of the 4-year cycle.
n1, n = divmod(n, 365)

year += n100 * 100 + n4 * 4 + n1
if n1 == 4 or n100 == 4:
assert n == 0
return year-1, 12, 31

# Now the year is correct, and n is the offset from January 1. We find
# the month via an estimate that's either exact or one too large.
leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
assert leapyear == _is_leap(year)
month = (n + 50) >> 5
preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)
if preceding > n: # estimate is too large
month -= 1
preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
n -= preceding
assert 0 <= n < _days_in_month(year, month)

# Now the year and month are correct, and n is the offset from the
# start of that month: we're done!
return year, month, n+1
# Count days from 0000-03-01, so that the leap day is the last day of
# its year. 0001-01-01 is day 306.
days = ordinal + 305

# Centuries average _DI400Y/4 days: three of 36524, then one of 36525.
century, rest = divmod(4 * days + 3, _DI400Y)
day_of_century = rest // 4

# Likewise, years average _DI4Y/4 days: three of 365, then one of 366.
year_of_century, rest = divmod(4 * day_of_century + 3, _DI4Y)
day_of_year = rest // 4

# From March, month lengths repeat 31, 30, 31, 30, 31 (153 days).
# 461 = 3*153 + 2 numbers the months from 3 (March) to 14 (February).
month, rest = divmod(5 * day_of_year + 461, 153)
Comment thread
StanFromIreland marked this conversation as resolved.
Resolved
day = rest // 5 + 1
year = 100 * century + year_of_century
if month > 12:
return year + 1, month - 12, day
return year, month, day

# Month and day names. For localized versions, see the calendar module.
_MONTHNAMES = [None, "Jan", "Feb", "Mar", "Apr", "May", "Jun",
Expand Down
24 changes: 24 additions & 0 deletions Lib/test/datetimetester.py
Original file line number Diff line number Diff line change
Expand Up @@ -1434,6 +1434,23 @@ def test_ordinal_conversions(self):
self.assertEqual(d, self.theclass.fromordinal(n))
n += 1

# Check the first and last days of every month in years at the
# start and the end of the 4-, 100- and 400-year cycles.
for year in (1, 3, 4, 5, 99, 100, 101, 399, 400, 401, 1899, 1900,
1901, 1999, 2001, 2100, 2399, 2400, 9996, 9999):
isleap = year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
n = self.theclass(year, 1, 1).toordinal()
for month, maxday in zip(range(1, 13), dim):
if month == 2 and isleap:
maxday += 1
for day, ordinal in (1, n), (maxday, n + maxday - 1):
with self.subTest(year=year, month=month, day=day):
d = self.theclass(year, month, day)
self.assertEqual(d.toordinal(), ordinal)
self.assertEqual(d, self.theclass.fromordinal(ordinal))
n += maxday
self.assertEqual(n, self.theclass(year, 12, 31).toordinal() + 1)

def test_extreme_ordinals(self):
a = self.theclass.min
a = self.theclass(a.year, a.month, a.day) # get rid of time parts
Expand All @@ -1455,6 +1472,13 @@ def test_extreme_ordinals(self):

self.assertRaises(ValueError, lambda: a.fromordinal(aord + 1))

# Past the maximum, the error still reports the year of the ordinal.
for n, year in ((aord + 1, 10000), (aord + 146097 + 1, 10400),
(2**31 - 1, 5879611)):
with self.subTest(n=n):
with self.assertRaisesRegex(ValueError, rf"\b{year}\b"):
self.theclass.fromordinal(n)

b = a - timedelta(days=1)
self.assertEqual(b.toordinal(), aord - 1)
self.assertEqual(b, self.theclass.fromordinal(aord - 1))
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
Speed up :meth:`datetime.datetime.fromordinal` by about 15% (30% in the
pure-Python implementation) by using the `Neri–Schneider algorithm
<https://doi.org/10.1002/spe.3172>`__.
112 changes: 34 additions & 78 deletions Modules/_datetimemodule.c
Original file line number Diff line number Diff line change
Expand Up @@ -471,88 +471,35 @@ days_before_month(int year, int month)
#define DI100Y 36524 /* _PyTime_DaysBeforeYear(101); days in 100 years */
#define DI400Y 146097 /* _PyTime_DaysBeforeYear(401); days in 400 years */

/* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */
/* ordinal -> year, month, day, considering 01-Jan-0001 as day 1.
*
* Neri and Schneider's algorithm, https://doi.org/10.1002/spe.3172; see
* _ord2ymd() in Lib/_pydatetime.py for an explanation of the steps.
*
* The intermediate values only fit in 32 bits for small ordinals;
* iso_to_ymd() passes the largest, MAXORDINAL + 2 (10000-01-02).
*/
static void
ord_to_ymd(int ordinal, int *year, int *month, int *day)
{
int n, n1, n4, n100, n400, leapyear, preceding;

/* ordinal is a 1-based index, starting at 1-Jan-1. The pattern of
* leap years repeats exactly every 400 years. The basic strategy is
* to find the closest 400-year boundary at or before ordinal, then
* work with the offset from that boundary to ordinal. Life is much
* clearer if we subtract 1 from ordinal first -- then the values
* of ordinal at 400-year boundaries are exactly those divisible
* by DI400Y:
*
* D M Y n n-1
* -- --- ---- ---------- ----------------
* 31 Dec -400 -DI400Y -DI400Y -1
* 1 Jan -399 -DI400Y +1 -DI400Y 400-year boundary
* ...
* 30 Dec 000 -1 -2
* 31 Dec 000 0 -1
* 1 Jan 001 1 0 400-year boundary
* 2 Jan 001 2 1
* 3 Jan 001 3 2
* ...
* 31 Dec 400 DI400Y DI400Y -1
* 1 Jan 401 DI400Y +1 DI400Y 400-year boundary
*/
assert(ordinal >= 1);
--ordinal;
n400 = ordinal / DI400Y;
n = ordinal % DI400Y;
*year = n400 * 400 + 1;

/* Now n is the (non-negative) offset, in days, from January 1 of
* year, to the desired date. Now compute how many 100-year cycles
* precede n.
* Note that it's possible for n100 to equal 4! In that case 4 full
* 100-year cycles precede the desired day, which implies the
* desired day is December 31 at the end of a 400-year cycle.
*/
n100 = n / DI100Y;
n = n % DI100Y;

/* Now compute how many 4-year cycles precede it. */
n4 = n / DI4Y;
n = n % DI4Y;

/* And now how many single years. Again n1 can be 4, and again
* meaning that the desired day is December 31 at the end of the
* 4-year cycle.
*/
n1 = n / 365;
n = n % 365;

*year += n100 * 100 + n4 * 4 + n1;
if (n1 == 4 || n100 == 4) {
assert(n == 0);
*year -= 1;
*month = 12;
*day = 31;
return;
assert(1 <= ordinal && ordinal <= MAXORDINAL + 2);
const uint32_t days = (uint32_t)ordinal + 305;
const uint32_t century = (4 * days + 3) / DI400Y;
const uint32_t day_of_century = (4 * days + 3) % DI400Y / 4;
const uint32_t year_of_century = (4 * day_of_century + 3) / DI4Y;
const uint32_t day_of_year = (4 * day_of_century + 3) % DI4Y / 4;
const uint32_t m = (5 * day_of_year + 461) / 153;
const uint32_t d = (5 * day_of_year + 461) % 153 / 5 + 1;
const uint32_t y = 100 * century + year_of_century;
if (m > 12) { /* January or February */
*year = (int)(y + 1);
*month = (int)(m - 12);
}

/* Now the year is correct, and n is the offset from January 1. We
* find the month via an estimate that's either exact or one too
* large.
*/
leapyear = n1 == 3 && (n4 != 24 || n100 == 3);
assert(leapyear == is_leap(*year));
*month = (n + 50) >> 5;
preceding = (_days_before_month[*month] + (*month > 2 && leapyear));
if (preceding > n) {
/* estimate is too large */
*month -= 1;
preceding -= days_in_month(*year, *month);
else {
*year = (int)y;
*month = (int)m;
}
n -= preceding;
assert(0 <= n);
assert(n < days_in_month(*year, *month));

*day = n + 1;
*day = (int)d;
}

/* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */
Expand Down Expand Up @@ -3439,7 +3386,16 @@ datetime_date_fromordinal_impl(PyTypeObject *type, int ordinal)
PyErr_SetString(PyExc_ValueError, "ordinal must be >= 1");
return NULL;
}
ord_to_ymd(ordinal, &year, &month, &day);
if (ordinal <= MAXORDINAL) {
ord_to_ymd(ordinal, &year, &month, &day);
}
else {
/* Out of range, but compute the year for the error message.
* The calendar repeats every 400 years (DI400Y days). */
int cycles = (ordinal - 1) / DI400Y;
ord_to_ymd(ordinal - cycles * DI400Y, &year, &month, &day);
year += 400 * cycles;
}
return new_date_subclass_ex(year, month, day, type);
}

Expand Down
Loading