generalize pd.Timestamp.min nanosecond-specific handling of near-minimum timestamps into a multiply-add function

Author: Robert Schmidtke

pandas/_libs/src/vendored/numpy/datetime/np_datetime.c

@@ -338,6 +338,41 @@ PyObject *extract_utc_offset(PyObject *obj) {
   return tmp;
 }
 
+static int scaleAndOffset(int64_t timestamp, int64_t scale, int64_t offset,
+                          int64_t *result) {
+  if (timestamp >= 0) {
+    // fast path for positive timestamps
+    if (checked_int64_mul(timestamp, scale, result) != 0) {
+      return 1;
+    }
+
+    return checked_int64_add(*result, offset, result);
+  }
+
+  // for negative timestamps, scaling could overflow
+  // even if the scaled and offset timestamp is valid
+  const int overflow = checked_int64_mul(timestamp, scale, result);
+  if (overflow != 0) {
+    // given the current scale, this is the smallest supported timestamp
+    const int64_t min_scalable_timestamp = (NPY_MIN_INT64 + 1) / scale;
+
+    // if the requested timestamp is just below that, doing the calculation
+    // in reverse from the absolute minimum timestamp could work
+    if (timestamp == min_scalable_timestamp - 1) {
+      const int64_t min_offset = (NPY_MIN_INT64 + 1) % scale;
+      if (checked_int64_sub(offset, min_offset, result) != 0) {
+        return 1;
+      }
+
+      return checked_int64_add(NPY_MIN_INT64 + 1, *result, result);
+    }
+
+    return 1;
+  }
+
+  return checked_int64_add(*result, offset, result);
+}
+
 static inline int scaleYearToEpoch(int64_t year, int64_t *result) {
   return checked_int64_sub(year, 1970, result);
 }
@@ -362,46 +397,6 @@ static inline int scaleDaysToWeeks(int64_t days, int64_t *result) {
   }
 }
 
-static inline int scaleDaysToHours(int64_t days, int64_t *result) {
-  return checked_int64_mul(days, 24, result);
-}
-
-static inline int scaleHoursToMinutes(int64_t hours, int64_t *result) {
-  return checked_int64_mul(hours, 60, result);
-}
-
-static inline int scaleMinutesToSeconds(int64_t minutes, int64_t *result) {
-  return checked_int64_mul(minutes, 60, result);
-}
-
-static inline int scaleSecondsToMilliseconds(int64_t seconds, int64_t *result) {
-  return checked_int64_mul(seconds, 1000, result);
-}
-
-static inline int scaleSecondsToMicroseconds(int64_t seconds, int64_t *result) {
-  return checked_int64_mul(seconds, 1000000, result);
-}
-
-static inline int scaleMicrosecondsToNanoseconds(int64_t microseconds,
-                                                 int64_t *result) {
-  return checked_int64_mul(microseconds, 1000, result);
-}
-
-static inline int scaleMicrosecondsToPicoseconds(int64_t microseconds,
-                                                 int64_t *result) {
-  return checked_int64_mul(microseconds, 1000000, result);
-}
-
-static inline int64_t scalePicosecondsToFemtoseconds(int64_t picoseconds,
-                                                     int64_t *result) {
-  return checked_int64_mul(picoseconds, 1000, result);
-}
-
-static inline int64_t scalePicosecondsToAttoseconds(int64_t picoseconds,
-                                                    int64_t *result) {
-  return checked_int64_mul(picoseconds, 1000000, result);
-}
-
 /*
  * Converts a datetime from a datetimestruct to a datetime based
  * on a metadata unit. Returns -1 on and sets PyErr on error.
@@ -440,80 +435,50 @@ npy_datetime npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT base,
   }
 
   int64_t hours;
-  PD_CHECK_OVERFLOW(scaleDaysToHours(days, &hours));
-  PD_CHECK_OVERFLOW(checked_int64_add(hours, dts->hour, &hours));
+  PD_CHECK_OVERFLOW(scaleAndOffset(days, 24, dts->hour, &hours));
 
   if (base == NPY_FR_h) {
     return hours;
   }
 
   int64_t minutes;
-  PD_CHECK_OVERFLOW(scaleHoursToMinutes(hours, &minutes));
-  PD_CHECK_OVERFLOW(checked_int64_add(minutes, dts->min, &minutes));
+  PD_CHECK_OVERFLOW(scaleAndOffset(hours, 60, dts->min, &minutes));
 
   if (base == NPY_FR_m) {
     return minutes;
   }
 
   int64_t seconds;
-  PD_CHECK_OVERFLOW(scaleMinutesToSeconds(minutes, &seconds));
-  PD_CHECK_OVERFLOW(checked_int64_add(seconds, dts->sec, &seconds));
+  PD_CHECK_OVERFLOW(scaleAndOffset(minutes, 60, dts->sec, &seconds));
 
   if (base == NPY_FR_s) {
     return seconds;
   }
 
   if (base == NPY_FR_ms) {
     int64_t milliseconds;
-    PD_CHECK_OVERFLOW(scaleSecondsToMilliseconds(seconds, &milliseconds));
     PD_CHECK_OVERFLOW(
-        checked_int64_add(milliseconds, dts->us / 1000, &milliseconds));
-
+        scaleAndOffset(seconds, 1000, dts->us / 1000, &milliseconds));
     return milliseconds;
   }
 
   int64_t microseconds;
-  PD_CHECK_OVERFLOW(scaleSecondsToMicroseconds(seconds, &microseconds));
-  PD_CHECK_OVERFLOW(checked_int64_add(microseconds, dts->us, &microseconds));
+  PD_CHECK_OVERFLOW(scaleAndOffset(seconds, 1000000, dts->us, &microseconds));
 
   if (base == NPY_FR_us) {
     return microseconds;
   }
 
   if (base == NPY_FR_ns) {
     int64_t nanoseconds;
-
-    // GH-57150: handle near-minimum valid timestamps
-    const int overflow = scaleMicrosecondsToNanoseconds(microseconds, &nanoseconds);
-    if (overflow != 0) {
-      // scaling overflows for pd.Timestamp.min (1677-09-21 00:12:43.145224193)
-      const int64_t near_min_scaled_microseconds = -9223372036854776LL;
-      if (microseconds == near_min_scaled_microseconds) {
-        // reverse calculation to avoid overflow
-        const int near_min_nanoseconds = 193;
-        int64_t nanoseconds_adder;
-        PD_CHECK_OVERFLOW(
-          checked_int64_sub(dts->ps / 1000, near_min_nanoseconds, &nanoseconds_adder));
-
-        // pd.Timestamp.min
-        nanoseconds = NPY_MIN_INT64 + 1;
-        PD_CHECK_OVERFLOW(
-            checked_int64_add(nanoseconds, nanoseconds_adder, &nanoseconds));
-
-        return nanoseconds;
-      }
-    }
-
-    PD_CHECK_OVERFLOW(overflow);
     PD_CHECK_OVERFLOW(
-        checked_int64_add(nanoseconds, dts->ps / 1000, &nanoseconds));
-
+        scaleAndOffset(microseconds, 1000, dts->ps / 1000, &nanoseconds));
     return nanoseconds;
   }
 
   int64_t picoseconds;
-  PD_CHECK_OVERFLOW(scaleMicrosecondsToPicoseconds(microseconds, &picoseconds));
-  PD_CHECK_OVERFLOW(checked_int64_add(picoseconds, dts->ps, &picoseconds));
+  PD_CHECK_OVERFLOW(
+      scaleAndOffset(microseconds, 1000000, dts->ps, &picoseconds));
 
   if (base == NPY_FR_ps) {
     return picoseconds;
@@ -522,16 +487,14 @@ npy_datetime npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT base,
   if (base == NPY_FR_fs) {
     int64_t femtoseconds;
     PD_CHECK_OVERFLOW(
-        scalePicosecondsToFemtoseconds(picoseconds, &femtoseconds));
-    PD_CHECK_OVERFLOW(
-        checked_int64_add(femtoseconds, dts->as / 1000, &femtoseconds));
+        scaleAndOffset(picoseconds, 1000, dts->as / 1000, &femtoseconds));
     return femtoseconds;
   }
 
   if (base == NPY_FR_as) {
     int64_t attoseconds;
-    PD_CHECK_OVERFLOW(scalePicosecondsToAttoseconds(picoseconds, &attoseconds));
-    PD_CHECK_OVERFLOW(checked_int64_add(attoseconds, dts->as, &attoseconds));
+    PD_CHECK_OVERFLOW(
+        scaleAndOffset(picoseconds, 1000000, dts->as, &attoseconds));
     return attoseconds;
   }