add pure int/divmod ordinal-to-ymd impl

Author: Rick Hull

lib/compsci/date.rb

@@ -124,7 +124,7 @@ def self.year_and_day(day_count)
       year = self.guess_year(day_count)
       year_days = self.year_days(year - 1)
 
-      # rewind the guess as needed
+      # rewind the guess as needed, typically 0 or 1x, rarely 2x
       while year > MIN_Y and year_days >= day_count
         year -= 1
         year_days -= self.annual_days(year)
@@ -146,12 +146,61 @@ def self.to_ordinal(year, month, day)
 
     # convert days since epoch back to Date
     def self.from_ordinal(day_count)
+      year, month, day = Date.to_ymd_flt(day_count)
+      Date.new(year:, month:, day:, ordinal_day: day_count)
+    end
+
+    # use floating point and heuristic, very efficient
+    def self.to_ymd_flt(day_count)
       unless day_count > 0
         raise(RuntimeError, "day_count should be positive: #{day_count}")
       end
-      year, annual_days = self.year_and_day(day_count)
-      month, day = self.month_and_day(annual_days, year)
-      Date.new(year:, month:, day:, ordinal_day: day_count)
+      year = self.guess_year(day_count)
+      year_days = self.year_days(year - 1)
+
+      # rewind the guess as needed, typically 0 or 1x, rarely 2x
+      while year > MIN_Y and year_days >= day_count
+        year -= 1
+        year_days -= self.annual_days(year)
+      end
+
+      month, day = self.month_and_day(day_count - year_days, year)
+      [year, month, day]
+    end
+
+    # use pure divmod arithmetic and integers; constant time; ~same~ efficiency
+    def self.to_ymd_int(day_count)
+      unless day_count > 0
+        raise(RuntimeError, "day_count should be positive: #{day_count}")
+      end
+
+      # Convert to 0-based day count for easier math
+      days = day_count - 1
+
+      # 400 year cycle
+      n400, days = days.divmod(DAYS_400)
+
+      # 100-year cycle
+      n100 = days / DAYS_100
+      n100 = 3 if n100 == 4
+      days -= (n100 * DAYS_100)
+
+      # 4-year cycle
+      n4, days = days.divmod(DAYS_4)
+
+      # remaining years
+      n1 = days / ANNUAL_DAYS
+      n1 = 3 if n1 == 4
+
+      # remaining days
+      days -= (n1 * ANNUAL_DAYS)
+
+      # determine the year
+      year = 1 + (n400 * 400) + (n100 * 100) + (n4 * 4) + n1
+
+      # add 1 back to 1-based day_count to determine the month and day
+      month, day = self.month_and_day(days + 1, year)
+      [year, month, day]
     end
 
     #
@@ -205,14 +254,13 @@ def initialize(year:, month:, day:, ordinal_day: nil)
       max_days = Date.month_days(month, year)
       raise(InvalidDay, day) unless (MIN_D..max_days).cover?(day)
 
-      @leap_year = Date.leap_year?(year)
+      # initialize
       @ordinal_day = ordinal_day || Date.to_ordinal(year, month, day)
-
       super(year:, month:, day:)
     end
 
     def leap_year?
-      @leap_year
+      Date.leap_year?(year)
     end
 
     def <=>(other)

test/bench/date.rb

@@ -35,57 +35,50 @@
   dates << [year, 8, rand(1..31)]
 }
 
-pairs = []
 
-999.times {
-  pairs << dates.sample(2)
-}
+# --- Benchmark 1: Object Creation ---
+puts "--- Benchmarking Object Creation (new) ---"
+d = dates.sample
 
 Benchmark.ips { |b|
   b.config(warmup: 0.2, time: 1)
-
-  b.report("Ruby Date Difference") {
-    pairs.each { |(d1, d2)|
-      rd1 = Date.new(*d1)
-      rd2 = Date.new(*d2)
-      rd1 - rd2
-    }
-  }
-
-  b.report("CompSciDate Difference") {
-    pairs.each { |(d1, d2)|
-      cd1 = CompSci::Date.new(*d1)
-      cd2 = CompSci::Date.new(*d2)
-      cd2.diff(cd1)
-    }
-  }
-
+  b.report("Ruby Date new") { Date.new(*d) }
+  b.report("CompSci::Date new") { CompSci::Date.new(*d) }
   b.compare!
 }
 
+# --- Benchmark 2: Date Arithmetic (+, -) ---
+# Create objects outside the loop so we only measure the arithmetic
+puts "\n--- Benchmarking Date Arithmetic (+, -) ---"
+rdate = Date.new(2024, 1, 1)
+cdate = CompSci::Date.new(year: 2024, month: 1, day: 1)
+days = rand(9999)
+
 Benchmark.ips { |b|
   b.config(warmup: 0.2, time: 1)
-
-  b.report("Ruby Date new") {
-    rd = Date.new(*dates.sample)
-    99.times {
-      rd + rand(9999)
-      rd - rand(9999)
-    }
+  b.report("Ruby Date +/-") {
+    rdate + days
+    rdate - days
   }
-
-  b.report("CompSci::Date new") {
-    cd = CompSci::Date.new(*dates.sample)
-    99.times {
-      val = rand(9999)
-      begin
-        cd + val
-        cd - val
-      rescue => e
-        puts format("Exception: %s: %s; %s +- %i", e.class, e.message, cd, val)
-      end
-    }
+  b.report("CompSci::Date +/-") {
+    cdate + days
+    cdate - days
   }
+  b.compare!
+}
 
+# --- Benchmark 3: Date Difference ---
+# Create objects outside the loop so we only measure the difference
+puts "\n--- Benchmarking Date Difference ---"
+d1, d2 = dates.sample(2)
+r1 = Date.new(*d1)
+r2 = Date.new(*d2)
+c1 = CompSci::Date.new(*d1)
+c2 = CompSci::Date.new(*d2)
+
+Benchmark.ips { |b|
+  b.config(warmup: 0.2, time: 1)
+  b.report("Ruby Date diff") { r1 - r2 }
+  b.report("CompSci::Date diff") { c1.diff(c2) }
   b.compare!
 }

test/bench/date_to_ymd.rb

@@ -0,0 +1,38 @@
+require 'benchmark/ips'
+require 'compsci/date'
+
+day_counts = []
+
+# Early years (where the leap day pattern hasn't fully established)
+(1..100).each { |d| day_counts << d }
+(360..400).each { |d| day_counts << d } # Around year 2
+(1460..1470).each { |d| day_counts << d } # Around the first 4-year cycle
+
+# Years far in the future (where the error of the linear approx accumulates)
+# Day counts for years 8000-9999
+(2_922_000..3_652_000).step(1000).each { |d| day_counts << d }
+
+# quick cross-check
+day_counts.each { |d|
+  f = CompSci::Date.to_ymd_flt(d)
+  i = CompSci::Date.to_ymd_int(d)
+
+  if f != i
+    raise format("flt != int: (%s, %s)", f.join('-'), i.join('-'))
+  end
+}
+
+puts "--- Benchmarking from_ordinal on Edge Case Dates ---"
+Benchmark.ips { |b|
+  b.config(warmup: 0.5, time: 2)
+
+  b.report("to_ymd_flt") {
+    CompSci::Date.to_ymd_flt(day_counts.sample)
+  }
+
+  b.report("to_ymd_int") {
+    CompSci::Date.to_ymd_int(day_counts.sample)
+  }
+
+  b.compare!
+}