seamusabshere-date-performance 0.0.1

data/AUTHORS

@@ -0,0 +1 @@
+rtomayko = Ryan Tomayko <rtomayko@gmail.com>

data/BENCHMARKS

@@ -0,0 +1,30 @@
+== WITH EXTENSION ==============================
+comparison
+  0.030000   0.000000   0.030000 (  0.027561)
+greater_than
+  0.030000   0.000000   0.030000 (  0.026667)
+new_civil
+  0.060000   0.000000   0.060000 (  0.063149)
+new_jd
+  0.060000   0.000000   0.060000 (  0.058935)
+strftime
+  0.020000   0.000000   0.020000 (  0.018389)
+strftime_after_new
+  0.080000   0.000000   0.080000 (  0.082086)
+strptime
+  0.070000   0.000000   0.070000 (  0.068235)
+== WITHOUT EXTENSION ===========================
+comparison
+  0.030000   0.000000   0.030000 (  0.027135)
+greater_than
+  0.030000   0.000000   0.030000 (  0.026128)
+new_civil
+  0.300000   0.000000   0.300000 (  0.303737)
+new_jd
+  0.110000   0.000000   0.110000 (  0.110033)
+strftime
+  0.230000   0.000000   0.230000 (  0.231178)
+strftime_after_new
+  0.850000   0.000000   0.850000 (  0.843894)
+strptime
+  3.000000   0.030000   3.030000 (  3.033587)

data/README.md

@@ -0,0 +1,134 @@
+Date::Performance
+=================
+
+This package adds some semblance of performance to Ruby's core Date class 
+using a combination of different techniques:
+
+1. Implements various core *Date* methods in C. This is nowhere near a
+   complete rewrite of all *Date* features but many of the hot spots have
+   been replaced with machine code.
+ 
+2. Provide alternate implementations of `strftime` and `strptime` in C.  The stock
+   date formatting and parsing methods are extremely slow compared to their
+   libc counterparts. *Date#sys_strftime* and *Date::sys_strptime* are light
+   facades on top of the system's `strftime(2)` and `strptime(2)`. The system 
+   methods run 10x and 50x (yes, _fifty-ecks_) faster than their Ruby based counterparts, 
+   respectively.  Unfortunately, `strftime(2)` and `strptime(2)` implementations vary from
+   system to system and have various limitations not found in the core Date
+   implementation so can not safely be used as replacements for the core methods.
+
+3. Memoization. The *Date::Memoize* module can be used to speed certain
+   types of repetitive date processing significantly. This file must be 
+   required separately.
+
+Synopsis
+--------
+
+This package is mostly transparent after an initial require:
+
+    require 'date/performance'
+    Date.new 1912, 6, 23
+    # Wow! That was fast!
+
+*Date::Performance* is not used directly but automatically replaces core *Date*
+methods when required.
+
+In addition to the C extension, the *Date::Memoization* module can be used to
+speed things up even further in some cases by making a trade off between space 
+and time:
+
+    require 'date/memoize'
+    Date.new 1912, 6, 23
+    Date.parse '1912-06-23'
+
+Requiring the file automatically replaces *Date::new* / *Date::civil*, *Date::parse*, 
+and *Date::jd* methods with memoized versions.
+
+Installation / Hacking
+----------------------
+
+This package has been tested on the following platforms:
+
+  * FreeBSD 5.4 (x86) and 6.1 (AMD64)
+  * Linux / Fedora Core 6 (x86)
+  * MacOS X (Intel)
+
+The easiest way to install the package is to use RubyGems:
+
+    $ gem install date-performance --source=http://tomayko.com
+
+Old versions and other dist formats are available at:
+
+    http://tomayko.com/dist/date-performance/
+
+A git repository is also available:
+
+    $ git clone git://github.com/rtomayko/date-performance.git
+
+Background
+----------
+
+The *Date* class is often the cause of poor performance in Ruby programs. A frequent
+suggestion is to use the *Time* class, which is much faster, but that solution has 
+correctness problems in a wide range of data typing cases. It is often the case that 
+you want separate *Date*, *Time*, and *DateTime* types.
+
+There are a couple of reasons why *Date* runs slowly when compared with
+*Time*. The common assumption is that this is mostly due to *Time* being
+written in C and *Date* being written in Ruby. While that clearly has an
+impact, I would argue that the reason *Date* is slow is because it's not
+designed to be fast. The code opts for readability over performance in almost
+every case. _This is a feature_.
+
+Have you read the *date.rb* documentation [1]? The implementation is pretty
+hard core; it can handle a lot of weird cases that *Time* [2] does not and
+would appear to be a correct implementation of date handling, which has the
+usual side-effect of being slow.
+
+The *Date* implementation uses a single Astronomical Julian Day (AJD) number
+to represent dates internally. In fact, *Date#initialize* takes a
+single `ajd` argument, which means that all date forms that are commonly used 
+(UNIX timestamp, Civil, etc.) must be converted to an AJD before we can even
+instantiate the thing. 
+
+The real performance hit seems to come from the various rational number
+operations performed on the way from a civil, ordinal, and julian date to 
+an AJD.
+
+When I began writing *Date::Performance*, I was getting pretty big (3x - 4x)
+performance boosts in many places simply by optimizing the Ruby code a bit.
+These boosts came at the expense of readability, however, and so the decision
+was made to go for _maximum unreadability_ and implement the boosts in C.
+
+There's a nice balance here: the Ruby implementation reads like a spec,
+while the C version implements it for quickness.
+
+Memoization
+-----------
+
+In addition to the C extension, this package includes a separate *Date::Memoize*
+module that can further speed up date processing in situations where the range
+of dates being manipulated is fairly dense and the same dates are being
+created repeatedly. Working with databases and flat files are two examples
+where memoization may help significantly.
+
+The *Date::Memoize* module replaces various Date constructor methods (`new`,
+`civil`, and `parse`) with memoized[http://en.wikipedia.org/wiki/Memoization] 
+versions (see *Date::Memoization* for details). The best way to determine 
+whether memoization is right for you is to add it to your project and see 
+what happens.
+
+License
+-------
+
+MIT. See the COPYING file included in the distribution for more 
+information.
+
+See Also
+--------
+
+ * [1] Ruby *Date* Implementation Notes and Documentation:
+   http://www.ruby-doc.org/docs/rdoc/1.9/files/_/lib/date_rb.html
+
+ * [2] Ruby *Time* documentation 
+   http://www.ruby-doc.org/docs/rdoc/1.9/classes/Time.html

data/Rakefile

@@ -0,0 +1,105 @@
+load 'misc/asciidoc.rake'
+load 'misc/project.rake'
+
+Project.new "Date::Performance" do |p|
+  p.package_name = 'date-performance'
+  p.version_file = 'lib/date/performance.rb'
+  p.summary = "Adds some semblance of performance to Ruby's core Date class."
+  p.project_url = "http://tomayko.com/src/date-performance/"
+  p.extra_files.include "ext/**/*.{rb,c,h}", "AUTHORS", "BENCHMARKS"
+  p.configure_package {|spec| spec.extensions = FileList["ext/**/extconf.rb"].to_a }
+  p.author = 'Ryan Tomayko <r@tomayko.com>'
+  p.rubyforge_project = 'wink'
+
+  p.remote_dist_location   = "gus@tomayko.com:/dist/#{p.package_name}"
+  p.remote_branch_location = "gus@tomayko.com:/src/#{p.package_name}.git"
+  p.remote_doc_location    = "gus@tomayko.com:/src/#{p.package_name}"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'date-performance'
+    gemspec.summary = "Adds some semblance of performance to Ruby's core Date class."
+    gemspec.email = 'Ryan Tomayko <r@tomayko.com>'
+    gemspec.homepage = "http://tomayko.com/src/date-performance/"
+    gemspec.description = "Adds some semblance of performance to Ruby's core Date class."
+    gemspec.authors = [ 'Ryan Tomayko', 'Alexander Dymo' ]
+    gemspec.files.include "ext/**/*.{rb,c,h}", "AUTHORS", "BENCHMARKS"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :default => [ :compile, :test ]
+
+file 'doc/index.txt' => 'README.md' do |f|
+  cp 'README.md', f.name
+end
+
+CLEAN.include [ "ext/*.{o,bundle}", "lib/*.{bundle,so,dll}" ]
+CLOBBER.include [ "ext/Makefile" ]
+
+if File.exist? 'misc/date-1.8.5'
+  desc "Run unit tests with Date from Ruby 1.8.5"
+  Rake::TestTask.new 'test:ruby185' do |t|
+    t.libs << "test"
+    t.libs << "misc/date-1.8.5"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+end
+
+task 'benchmark.without' do |t|
+  verbose false do
+    puts '== WITHOUT EXTENSION ==========================='
+    ruby "-Ilib test/benchmarks.rb"
+  end
+end
+
+task 'benchmark.with' do |t|
+  verbose false do
+    puts '== WITH EXTENSION =============================='
+    ruby "-Ilib -rdate/performance test/benchmarks.rb"
+  end
+end
+
+desc "Run benchmarks"
+task :benchmark => [ 'benchmark.without', 'benchmark.with' ]
+
+# Extension =================================================================
+
+DLEXT = Config::CONFIG['DLEXT']
+
+directory "lib"
+
+desc "Build the extension"
+task "date_performance" => [ "lib/date_performance.#{DLEXT}" ]
+
+file "ext/Makefile" => FileList[ "ext/*.{c,h,rb}" ] do
+  Dir.chdir("ext") { ruby "extconf.rb" }
+end
+
+file "ext/date_performance.#{DLEXT}" => FileList["ext/*.c", "ext/Makefile"] do |f|
+  Dir.chdir("ext") { sh "make" }
+end
+
+file "lib/date_performance.#{DLEXT}" => [ "ext/date_performance.#{DLEXT}" ] do |t|
+  cp "ext/date_performance.#{DLEXT}", t.name
+end
+
+desc "Compiles all extensions"
+task :compile => [ "lib/date_performance.#{DLEXT}" ]
+
+# Rubyforge =================================================================
+
+VERS = Project.current.version
+PKGNAME = "dist/date-performance-#{VERS}"
+
+desc 'Publish new release to rubyforge'
+task :release => [ "#{PKGNAME}.gem", "#{PKGNAME}.tar.gz" ] do |t|
+  sh <<-end
+    rubyforge add_release wink date-performance #{VERS} #{PKGNAME}.gem &&
+    rubyforge add_file    wink date-performance #{VERS} #{PKGNAME}.tar.gz
+  end
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 1

data/ext/date_performance.c

@@ -0,0 +1,440 @@
+
+/*
+ * Enable C99 extensions to enable fast float rounding stuff in math.h.
+ */
+#define	_ISOC9X_SOURCE	1
+#define _ISOC99_SOURCE	1
+
+#include <math.h>
+#include <ruby.h>
+#include <time.h>
+
+#define FLOOR(a) lrintf(floorf(a))
+#define FLOAT(a) (float)a
+
+static VALUE rb_cDate;      /* class Date */
+static VALUE rb_cRational;  /* class Rational */
+
+static ID id_subtract;      /* :- */
+static ID id_add;           /* :+ */
+static ID id_divmod;        /* :divmod */
+static ID id_new;           /* :new */
+static ID id_new_bang;      /* :new! */
+static ID id_ivar_civil;    /* :@__civil__ */
+static ID id_jd;            /* :jd */
+static ID id_ivar_ajd;      /* :@ajd */
+static ID id_jd_to_civil;   /* :jd_to_civil */
+static ID id_ivar_sg;       /* :@sg */
+static ID id_numerator;     /* :numerator */
+static ID id_denominator;   /* :denominator */
+
+static ID id_strptime_without_performance;
+static ID id_strftime_without_performance;
+
+static VALUE JULIAN;        /* Date::JULIAN */
+static VALUE GREGORIAN;     /* Date::GREGORIAN */
+static VALUE ITALY;         /* Date::ITALY */
+
+static VALUE ra_one_half;    /* Rational(1, 2) */
+static VALUE DEFAULT_FORMAT; /* "%F" */
+
+static int initialized = 0;
+
+static inline int 
+civil_to_jd(int y, int m, int d, VALUE sg)
+{
+  int a, b, jd;
+  if ( m <= 2 ) {
+    y-= 1;
+    m+= 12;
+  }
+  a = y / 100;
+  b = 2 - a + (a / 4);
+  jd = FLOOR(365.25 * (y + 4716)) +
+    FLOOR(30.6001 * (m + 1)) +
+    d + b - 1524;
+  if ( sg == JULIAN || (sg != GREGORIAN && jd < FIX2INT(sg)) )
+    jd -= b;
+  return jd;
+}
+
+
+/*
+ * Date::civil_to_jd(year, month, day, sg=Date::GREGORIAN)
+ */
+static VALUE 
+rb_date_civil_to_jd(int argc, VALUE* argv, VALUE self)
+{
+  int y  = FIX2INT(argv[0]), 
+      m  = FIX2INT(argv[1]), 
+      d  = FIX2INT(argv[2]);
+  VALUE sg = (argc == 4 ? argv[3] : GREGORIAN);
+  return INT2FIX(civil_to_jd(y, m, d, sg));
+}
+
+
+struct mini_tm {
+  int y;
+  int m;
+  int d;
+};
+
+
+static inline void
+jd_to_civil(int jd, VALUE sg, struct mini_tm * t)
+{
+  int a, b, c, d, e;
+  if ( sg == JULIAN || (sg != GREGORIAN && jd < FIX2INT(sg)) ) { /* julian? */
+    a = jd;
+  }else{
+    int x = FLOOR((jd - 1867216.25) / 36524.25);
+    a = jd + 1 + x - FLOOR(x / 4.0);
+  }
+  b = a + 1524;
+  c = FLOOR((b - 122.1) / 365.25);
+  d = FLOOR(365.25 * c);
+  e = FLOOR((b - d) / 30.6001);
+  t->d = b - d - FLOOR(30.6001 * e);
+  if ( e <= 13 ) {
+    t->m = e - 1;
+    t->y = c - 4716;
+  }else{
+    t->m = e - 13;
+    t->y = c - 4715;
+  }
+}
+
+
+/*
+ * Date::jd_to_civil(jd, sg=GREGORIAN)
+ */
+static VALUE 
+rb_date_jd_to_civil(int argc, VALUE * argv, VALUE self)
+{
+  int    jd = FIX2INT(argv[0]);
+  VALUE  sg = (argc == 2 ? argv[1] : GREGORIAN);
+  struct mini_tm t;
+  jd_to_civil(jd, sg, &t);
+  return rb_ary_new3(3, INT2FIX(t.y), INT2FIX(t.m), INT2FIX(t.d));
+}
+
+
+/*
+ * Calculate the AJD from a julian date, fractional day, and offset.
+ */
+static inline VALUE
+jd_to_ajd(long jd, VALUE fr, VALUE of)
+{
+  /* Ruby Implementation: jd + fr - of - 1.to_r/2 */
+  if ( TYPE(fr) == T_FIXNUM && TYPE(of) == T_FIXNUM ) {
+    /* fast path the common case of no fraction and no offset */
+    long numerator = (((jd + FIX2LONG(fr) - FIX2LONG(of)) - 1) * 2) + 1;
+    return rb_funcall(rb_cRational, id_new, 2, LONG2FIX(numerator), LONG2FIX(2));
+  }else{
+    /* use slower rational math */
+    VALUE result = rb_funcall(rb_cRational, id_new, 2, LONG2FIX(jd), LONG2FIX(1));
+    result = rb_funcall(result, id_add, 1, fr);
+    if ( of != LONG2FIX(0) ) 
+      result = rb_funcall(result, id_subtract, 1, of);
+    result = rb_funcall(result, id_subtract, 1, ra_one_half);
+    return result;
+  }
+}
+
+
+/*
+ * Date::jd_to_ajd(jd, fr, of=0)
+ */
+static VALUE
+rb_date_jd_to_ajd(int argc, VALUE * argv, VALUE self)
+{
+  long jd = FIX2LONG(argv[0]);
+  VALUE fr = (argc > 1 ? argv[1] : LONG2FIX(0));
+  VALUE of = (argc > 2 ? argv[2] : LONG2FIX(0));
+  return jd_to_ajd(jd, fr, of);
+}
+
+
+/*
+ * Date::ajd_to_jd(ajd, of=0)
+ *
+ * TODO: handle offsets properly.
+ *
+ * Ruby Implementation: (ajd + of + 1.to_r/2).divmod(1)
+ */
+static VALUE
+rb_date_ajd_to_jd(int argc, VALUE * argv, VALUE self)
+{
+  VALUE ajd = argv[0];
+  VALUE of  = (argc == 2 ? argv[1] : INT2FIX(0));
+  long den = FIX2LONG(rb_funcall(ajd, id_denominator, 0));
+  long num = FIX2LONG(rb_funcall(ajd, id_numerator, 0));
+  if ( den == 2 && of == INT2FIX(0) ) {
+    /* fast path */
+    return rb_ary_new3(2, LONG2FIX((num + 1) / 2), ra_one_half);
+  }else{
+    VALUE result = rb_funcall(ajd, id_add, 1, of);
+    result = rb_funcall(result, id_add, 1, ra_one_half);
+    return rb_funcall(result, id_divmod, 1, LONG2FIX(1));
+  }
+}
+
+
+/*
+ * Date::new(y=-4712, m=1, d=1, sg=ITALY)
+ */
+static VALUE 
+rb_date_new(int argc, VALUE * argv, VALUE self) {
+  int y    = (argc > 0 ? NUM2INT(argv[0]) : -4712),
+      m    = (argc > 1 ? NUM2INT(argv[1]) : 1),
+      d    = (argc > 2 ? NUM2INT(argv[2]) : 1);
+  VALUE sg = (argc > 3 ? argv[3] : ITALY);
+  int jd = -1;
+  struct mini_tm t;
+  if (d < 0) {
+    int ny = (y * 12 + m) / 12;
+    int nm = (y * 12 + m) % 12;
+    nm = (nm + 1) / 1;
+    jd = civil_to_jd(ny, nm, d+1, sg);
+
+    VALUE ns = jd < 2299161 ? JULIAN : GREGORIAN;
+    jd_to_civil(jd-d, ns, &t);
+    if ( t.y != ny || t.m != nm || t.d != 1 ) {
+      rb_raise(rb_eArgError, "Invalid date: (%d, %d, %d)", y, m, d);
+      return Qnil;
+    }
+    jd_to_civil(jd, sg, &t);
+    if ( t.y != y || t.m != m ) {
+      rb_raise(rb_eArgError, "Invalid date: (%d, %d, %d)", y, m, d);
+      return Qnil;
+    }
+  } else {
+    jd = civil_to_jd(y, m, d, sg);
+    jd_to_civil(jd, sg, &t);
+    if ( t.y != y || t.m != m || t.d != d ) {
+      rb_raise(rb_eArgError, "Invalid date: (%d, %d, %d)", y, m, d);
+      return Qnil;
+    }
+  }
+  VALUE ajd = jd_to_ajd(jd, INT2FIX(0), INT2FIX(0));
+  VALUE date = rb_funcall(self, id_new_bang, 3, ajd, INT2FIX(0), sg);
+  rb_ivar_set(date, id_ivar_civil, rb_ary_new3(3, INT2FIX(t.y), INT2FIX(t.m), INT2FIX(t.d)));
+  return date;
+}
+
+
+/*
+ * Date#civil
+ *
+ * Fast path the case where the date is created with civil parameters.
+ */
+static VALUE
+rb_date_civil(VALUE self) {
+  if ( rb_ivar_defined(self, id_ivar_civil) == Qfalse ) {
+    VALUE jd = rb_funcall(self, id_jd, 0);
+    VALUE sg = rb_ivar_get(self, id_ivar_sg);
+    VALUE result = rb_funcall(rb_cDate, id_jd_to_civil, 2, jd, sg);
+    return rb_ivar_set(self, id_ivar_civil, result);
+  }else{
+    return rb_ivar_get(self, id_ivar_civil);
+  }
+}
+
+
+/*
+ * Date#sys_strftime(fmt="%F")
+ */
+static VALUE
+rb_date_strftime(int argc, VALUE * argv, VALUE self)
+{
+  VALUE format = (argc > 0 ? *argv : DEFAULT_FORMAT);
+  VALUE civil = rb_date_civil(self);
+
+  char  * pf = RSTRING(format)->ptr;
+  VALUE * pc = RARRAY(civil)->ptr;
+  int ic[3];
+
+  ic[0] = FIX2INT(pc[0]);
+  ic[1] = FIX2INT(pc[1]);
+  ic[2] = FIX2INT(pc[2]);
+
+  /* fast path default format: %F or %Y-%m-%d */
+  if ( (pf[0] == '%' && pf[1] == 'F' && pf[2] == 0) ||
+       (pf[0] == '%' && pf[1] == 'Y' && pf[2] == '-' 
+     && pf[3] == '%' && pf[4] == 'm' && pf[5] == '-'
+     && pf[6] == '%' && pf[7] == 'd' && pf[8] == 0) )
+  {
+    VALUE buf = rb_str_buf_new(11);
+    char  * pb = RSTRING(buf)->ptr;
+    RSTRING(buf)->len = 
+      sprintf(pb, "%04d-%02d-%02d", ic[0], ic[1], ic[2]);
+    return buf;
+  }
+ 
+  /* Use libc's strftime but only for Date class */
+  if ( RBASIC(self)->klass == rb_cDate ){
+    VALUE buf = rb_str_buf_new(128);
+    char  * pb = RSTRING(buf)->ptr;
+    struct tm t;
+    bzero(&t, sizeof(struct tm));
+    t.tm_year = ic[0] - 1900;
+    t.tm_mon  = ic[1] - 1;
+    t.tm_mday = ic[2];
+    mktime(&t);  /* fill in missing items (tm_wday, tm_yday) */
+    if ( (RSTRING(buf)->len = strftime(pb, 128, pf, &t)) > 0 )
+      return buf;
+  }
+
+  /* fall back on Ruby implementation if libc's strftime fails */
+  return rb_funcall2(self, id_strftime_without_performance, argc, argv);
+}
+
+
+/*
+ * Date::strptime(str="-4712-01-01", fmt='%F')
+ */
+static VALUE
+rb_date_strptime(int argc, VALUE * argv, VALUE self)
+{
+  char *pe;
+  struct tm buf;
+  VALUE str = (argc > 0 ? argv[0] : rb_str_new2("-4712-01-01")),
+        fmt = (argc > 1 ? argv[1] : DEFAULT_FORMAT),
+        sg  = (argc > 2 ? argv[2] : ITALY);
+  char * ps = RSTRING(str)->ptr;
+  char * pf = RSTRING(fmt)->ptr;
+  VALUE parts[4];
+
+  /* fast path default format */
+  if ( (pf[0] == '%' && pf[1] == 'F' && pf[0])
+    || (pf[0] == '%' && pf[1] == 'Y' && pf[2] == '-' 
+     && pf[3] == '%' && pf[4] == 'm' && pf[5] == '-'
+     && pf[6] == '%' && pf[7] == 'd' && pf[8] == 0) )
+  {
+    parts[0] = INT2FIX(strtol(ps, &pe, 10));
+    parts[1] = Qnil;
+    parts[2] = Qnil; 
+    parts[3] = sg;
+    if( pe == ps + 4 )  { 
+      parts[1] = INT2FIX(strtol(ps + 5, &pe, 10));
+      if ( pe == ps + 7 ) { 
+        parts[2] = INT2FIX(strtol(ps + 8, &pe, 10));
+        if ( pe == ps + 10 )
+          return rb_date_new(4, (VALUE*)&parts, self);
+      }
+    }
+  }
+
+  /* fall back on strptime(3) */
+  if ( strptime(ps, pf, &buf) )
+  {
+    parts[0] = INT2FIX(buf.tm_year + 1900);
+    parts[1] = INT2FIX(buf.tm_mon  + 1);
+    parts[2] = INT2FIX(buf.tm_mday);
+    parts[3] = sg;
+    return rb_date_new(4, (VALUE*)&parts, self);
+  }
+
+  /* if that doesn't work, fall back on Ruby implementation */
+  return rb_funcall2(self, id_strptime_without_performance, argc, argv);
+}
+
+/*
+ * Date::<=>(other)
+*/
+static VALUE
+rb_date_compare(int argc, VALUE * argv, VALUE self)
+{
+  if (NIL_P(argv[0]))
+    return Qnil;
+  long other_den = -1;
+  long other_num = -1;
+  if (FIXNUM_P(argv[0])) {
+    //compare with argument as with astronomical julian day number
+    other_den = 1;
+    other_num = FIX2LONG(argv[0]);
+  } else if (rb_obj_is_kind_of(argv[0], rb_cDate)) {
+    VALUE other_date = argv[0];
+    VALUE other_ajd = rb_ivar_get(other_date, id_ivar_ajd);
+    other_den = FIX2LONG(rb_funcall(other_ajd, id_denominator, 0));
+    other_num = FIX2LONG(rb_funcall(other_ajd, id_numerator, 0));
+  } else {
+    return Qnil;
+  }
+  
+  VALUE ajd = rb_ivar_get(self, id_ivar_ajd);
+  long den = FIX2LONG(rb_funcall(ajd, id_denominator, 0));
+  long num = FIX2LONG(rb_funcall(ajd, id_numerator, 0));
+
+  long v = (num * other_den) - (other_num * den);
+  if (v > 0)
+    return INT2FIX(1);
+  else if (v < 0)
+    return INT2FIX(-1);
+  else
+    return INT2FIX(0);
+}
+
+
+VALUE
+Init_date_performance() {
+  /* initialization is not idemponent - make sure it only happens once. */
+  if ( initialized )
+    rb_raise(rb_eStandardError, "date_performance extension already initialized.");
+  initialized = 1;
+
+  /* Grab Date class */
+  rb_require("date");
+  rb_cDate = rb_define_class("Date", rb_cObject);
+  
+  if( ! rb_const_defined_from(rb_cDate, rb_intern("Performance")) ) 
+    rb_raise(rb_eStandardError, 
+        "Date::Performance not defined. The date_performance extension can not be required directly.");
+
+  /* Date Instance Methods */
+  rb_define_method(rb_cDate, "civil",        rb_date_civil, 0);
+  rb_define_method(rb_cDate, "sys_strftime", rb_date_strftime, -1);
+  rb_define_method(rb_cDate, "strftime",     rb_date_strftime, -1);
+  rb_define_method(rb_cDate, "<=>",          rb_date_compare, -1);
+
+  /* Date Singleton Methods */
+  rb_define_singleton_method(rb_cDate, "civil_to_jd",   rb_date_civil_to_jd, -1);
+  rb_define_singleton_method(rb_cDate, "jd_to_civil",   rb_date_jd_to_civil, -1);
+  rb_define_singleton_method(rb_cDate, "jd_to_ajd",     rb_date_jd_to_ajd, -1);
+  rb_define_singleton_method(rb_cDate, "ajd_to_jd",     rb_date_ajd_to_jd, -1);
+  rb_define_singleton_method(rb_cDate, "new",           rb_date_new, -1);
+  rb_define_singleton_method(rb_cDate, "civil",         rb_date_new, -1);
+  rb_define_singleton_method(rb_cDate, "sys_strptime",  rb_date_strptime, -1);
+  rb_define_singleton_method(rb_cDate, "strptime",      rb_date_strptime, -1);
+
+  /* Date Related Constants */
+  JULIAN = rb_eval_string("Date::JULIAN");
+  GREGORIAN = rb_eval_string("Date::GREGORIAN");
+  ITALY = INT2FIX(2299161);
+
+  DEFAULT_FORMAT = rb_str_new2("%F");
+  rb_gc_register_address(&DEFAULT_FORMAT);
+
+  /* Symbol Constants */
+  id_subtract = rb_intern("-");
+  id_add = rb_intern("+");
+  id_divmod = rb_intern("divmod");
+  id_new = rb_intern("new");
+  id_jd = rb_intern("jd");
+  id_ivar_ajd = rb_intern("@ajd");
+  id_jd_to_civil = rb_intern("jd_to_civil");
+  id_ivar_civil = rb_intern("@__civil__");
+  id_ivar_sg = rb_intern("@sg");
+  id_new_bang = rb_intern("new!");
+  id_numerator = rb_intern("numerator");
+  id_denominator = rb_intern("denominator");
+  id_strptime_without_performance = rb_intern("strptime_without_performance");
+  id_strftime_without_performance = rb_intern("strftime_without_performance");
+
+  /* Rational Stuff */
+  rb_require("rational");
+  rb_cRational = rb_define_class("Rational", rb_cNumeric);
+  ra_one_half = rb_funcall(rb_cRational, id_new, 2, INT2FIX(1), INT2FIX(2));
+  rb_gc_register_address(&ra_one_half);
+  return Qnil;
+}

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+# Disable warnings from ld
+$LDFLAGS = "-w"
+# turn on warnings from gcc
+$CFLAGS = "-pedantic -Wall -Wno-long-long -Winline"
+
+dir_config 'date_performance'
+create_makefile 'date_performance'

data/lib/date/memoize.rb

@@ -0,0 +1,86 @@
+# See Date::Memoize.
+
+require 'date'
+require 'date/performance'
+
+class Date #:nodoc:
+
+  # Adds memoization to Date. This can speed things up significantly in cases where a lot 
+  # of the same Date objects are created.
+  module Memoize
+
+    # Memoized version of Date::strptime.
+    def strptime(str='-4712-01-01', fmt='%F', sg=ITALY)
+      @__memoized_strptime_dates[ [ str, fmt, sg ] ]
+    end
+
+    # Memoized version Date::parse.
+    def parse(str='-4712-01-01', comp=false, sg=ITALY)
+      @__memoized_parse_dates[ [ str, comp, sg ] ]
+    end
+
+    # Memoized version of Date::civil.
+    def civil(y=-4712, m=1, d=1, sg=ITALY)
+      @__memoized_civil_dates[ [ y, m, d, sg ] ]
+    end
+
+    alias_method :new, :civil
+
+  public
+
+    # The methods we'll be replacing on the Date singleton.
+    def self.methods_replaced
+      [ :new, :civil, :strptime, :parse ]
+    end
+
+    # Overridden to move the existing methods out of the way before copying this module's
+    # methods.
+    def self.extend_object(base)
+      singleton = (class<<base;self;end)
+      methods_replaced.each do |method|
+        singleton.send :alias_method, "#{method}_without_memoization", method
+        singleton.send :remove_method, method
+      end
+      base.send :instance_variable_set, :@__memoized_civil_dates, 
+        Hash.new{|h,key| h[key]=Date.new_without_memoization(*key)}
+      base.send :instance_variable_set, :@__memoized_strptime_dates, 
+        Hash.new{|h,key| h[key]=Date.strptime_without_memoization(*key)}
+      base.send :instance_variable_set, :@__memoized_parse_dates, 
+        Hash.new{|h,key| h[key]=Date.parse_without_memoization(*key)}
+      super
+    end
+
+    # Removes memoization methods from singleton of the class provided.
+    def self.unextend_object(base)
+      singleton = (class<<base;self;end)
+      methods_replaced.each do |method|
+        singleton.send :alias_method,  method, "#{method}_without_memoization"
+        singleton.send :remove_method, "#{method}_without_memoization"
+      end
+      base.send :remove_instance_variable, :@__memoized_civil_dates
+      base.send :remove_instance_variable, :@__memoized_strptime_dates
+      base.send :remove_instance_variable, :@__memoized_parse_dates
+      base
+    end
+
+    # Is Date memoization currently installed and active?
+    def self.installed?
+      Date.respond_to? :civil_without_memoization
+    end
+
+    # Extend the Date class with memoized versions of +new+ and +civil+ but only if 
+    # memoization has not yet been installed.
+    def self.install!
+      Date.extend self unless installed?
+    end
+
+    # Remove memoized methods and free up memo cache. This method is idempotent.
+    def self.uninstall!
+      unextend_object Date if installed?
+    end
+
+  end
+
+  Memoize.install!
+
+end

data/lib/date/performance.rb

@@ -0,0 +1,44 @@
+require 'date'
+
+# Loading this file is not idemponent and can cause damage when loaded twice.
+# Fail hard and fast.
+fail "Date::Performance already loaded." if defined? Date::Performance
+
+class Date
+
+  # The Date::Performance module is present when the performance enhacing extension 
+  # has been loaded. It serves no other purpose.
+  module Performance
+    VERSION = "0.4.7"
+  end
+
+  # The extension replaces Date#strftime but falls back on the stock version when
+  # strftime(3) cannot handle the format.
+  alias_method :strftime_without_performance, :strftime
+
+  class << self
+    # Ruby 1.8.6 introduced Date.new! and the extension uses it. The method was 
+    # called new0 in <= 1.8.5.
+    alias_method :new!, :new0 unless Date.respond_to?(:new!)
+
+    # The extension replaces Date.strptime but falls back on the stock version when 
+    # strptime(3) can't handle the format.
+    alias_method :strptime_without_performance, :strptime
+  end
+
+end
+
+# Load up the extension but bring the Date class back to its original state
+# if the extension fails to load properly.
+begin
+  require 'date_performance.so'
+rescue
+  class Date
+    remove_const  :Performance
+    remove_method :strftime_without_performance
+    class << self
+      remove_method :strptime_without_performance
+    end
+  end
+  raise
+end

data/test/benchmarks.rb

@@ -0,0 +1,68 @@
+$: << 'lib'
+require 'date'
+# require 'date/fast'
+
+def profile_new_civil(iterations=1000)
+  iterations.times do |i|
+    Date.new(1912, 6, 23)
+  end
+end
+
+def profile_new_jd(iterations=1000)
+  jd = Date.civil_to_jd(1912, 6, 23, Date::ITALY)
+  iterations.times do |i|
+    Date.jd(jd)
+  end
+end
+
+def profile_comparison(iterations=1000)
+  d1, d2 = Date.new(1912, 6, 23), Date.new(1906, 4, 28)
+  iterations.times do |i|
+    d1 == d2
+  end
+end
+
+def profile_greater_than(iterations=1000)
+  d1, d2 = Date.new(1912, 6, 23), Date.new(1906, 4, 28)
+  iterations.times do |i|
+    d1 > d2
+  end
+end
+
+def profile_strftime(iterations=1000)
+  date = Date.new(1912, 6, 23)
+  iterations.times do |i|
+    date.strftime
+  end
+end
+
+def profile_strftime_after_new(iterations=1000)
+  iterations.times do |i|
+    Date.new(1912, 6, 23).strftime
+  end
+end
+
+def profile_strptime(iterations=1000)
+  iterations.times do |i|
+    Date.strptime '06/23/1912', '%m/%d/%Y'
+  end
+end
+
+def run_profiles
+  require 'benchmark'
+  all_methods = private_methods.select{|m| m =~ /^profile_/}.map{|m| m.sub /^profile_/, '' }.sort
+  selected_methods = 
+    if ARGV.empty?
+     all_methods
+   else
+     ARGV
+   end
+  # warm-up
+  selected_methods.each {|method| send "profile_#{method}", 1 }
+  selected_methods.each do |method|
+    puts method
+    puts Benchmark.measure{ send "profile_#{method}", 10000 }
+  end
+end
+
+run_profiles

data/test/date_memoize_test.rb

@@ -0,0 +1,70 @@
+require 'date/performance'
+require 'date/memoize'
+require 'test/unit'
+
+class DateMemoizeTest < Test::Unit::TestCase
+
+  def setup
+    Date::Memoize.install!
+  end
+
+  def test_installed_by_default
+    assert Date::Memoize.installed?, "didn't install when required"
+  end
+
+  def test_civil_memoization
+    expected = Date.new_without_memoization(2002, 03, 22)
+    actual = Date.new(2002, 03, 22)
+    assert_not_same expected, actual
+    assert_equal expected, actual
+    expected, actual = actual, Date.new(2002, 03, 22)
+    assert_same expected, actual
+    assert_equal expected, actual
+  end
+
+  def test_strptime_memoization
+    Date::Memoize.uninstall!
+    expected = Date.strptime('2002-03-22', '%Y-%m-%d')
+    Date::Memoize.install!
+    actual = Date.strptime('2002-03-22', '%Y-%m-%d')
+    assert_equal expected, actual
+    assert_not_same expected, actual
+    expected, actual = actual, Date.strptime('2002-03-22', '%Y-%m-%d')
+    assert_same expected, actual
+    assert_equal expected, actual
+  end
+
+  def test_parse_memoization
+    Date::Memoize.uninstall!
+    expected = Date.parse('2002-03-22')
+    Date::Memoize.install!
+    actual = Date.parse('2002-03-22')
+    assert_equal expected, actual
+    assert_not_same expected, actual, "With (#{actual.to_s}) and without (#{expected.to_s}) memoization are the same (#{actual.object_id}, #{expected.object_id})."
+    expected, actual = actual, Date.parse('2002-03-22')
+    assert_same expected, actual
+    assert_equal expected, actual
+  end
+
+  def test_uninstall_is_detected
+    Date::Memoize.uninstall!
+    assert !Date::Memoize.installed?, "didn't uninstall or uninstall not detected properly"
+    methods = Date.methods.select{|m| m.to_s =~ /_without_memoization$/}
+    flunk "Memoization methods not removed: #{methods.inspect}" if methods.any?
+    vars = Date.send(:instance_variables).select{|v| v.to_s =~ /^@__memoized_/}
+    flunk "Memoization instance variables not removed: #{vars.inspect}" if vars.any?
+  end
+
+  def test_uninstall_removes_methods
+    Date::Memoize.uninstall!
+    methods = Date.methods.select{|m| m.to_s =~ /_without_memoization$/}
+    assert_equal 0, methods.length, "Memoization methods not removed: #{methods.inspect}"
+  end
+
+  def test_uninstall_removes_instance_variables
+    Date::Memoize.uninstall!
+    vars = Date.send(:instance_variables).select{|v| v.to_s =~ /^@__memoized_/}
+    assert_equal 0, vars.length, "Memoization instance variables not removed: #{vars.inspect}"
+  end
+
+end

data/test/extension_test.rb

@@ -0,0 +1,145 @@
+require 'date/performance'
+require 'test/unit'
+
+class ExtensionTest < Test::Unit::TestCase
+
+  def test_civil_to_jd
+    assert_equal 2419577, Date.civil_to_jd(1912, 6, 23)
+    assert_equal 2419577, Date.civil_to_jd(1912, 6, 23, Date::GREGORIAN)
+  end
+
+  def test_jd_to_civil
+    expected = [ 1912, 6, 23 ]
+    assert_equal expected, Date.jd_to_civil(2419577)
+    assert_equal expected, Date.jd_to_civil(2419577, Date::GREGORIAN)
+  end
+
+  def test_jd_to_ajd
+    expected = Rational(4839153, 2)
+    assert_equal expected, Date.jd_to_ajd(2419577)
+    assert_equal expected, Date.jd_to_ajd(2419577, 0)
+    assert_equal expected, Date.jd_to_ajd(2419577, 0, 0)
+  end
+
+  def test_ajd_to_jd
+    ajd = Rational(4839153, 2)
+    expected = [ 2419577, Rational(1, 2) ]
+    assert_equal(expected, Date.ajd_to_jd(ajd))
+    assert_equal(expected, Date.ajd_to_jd(ajd, 0))
+  end
+
+  def test_new
+    expected = Date.new!(Rational(4839153, 2))
+    assert_equal expected, Date.new(1912, 6, 23)
+    assert_equal expected, Date.new(1912, 6, 23, Date::ITALY)
+  end
+
+  def test_new_raises_argument_error
+    assert_raise ArgumentError do
+      Date.new(1912, 25, 55)
+    end
+  end
+
+  def test_civil_cached_on_new
+    date = Date.new(1912, 6, 23)
+    assert_not_nil(expected = date.send(:instance_variable_get, :@__civil__))
+    assert_equal expected, date.civil
+  end
+
+  def test_civil_cached_on_new!
+    date = Date.new!(Rational(4839153, 2))
+    assert !date.send(:instance_variables).include?('@__civil__'), '@__civil__ ivar should not exist'
+    assert_equal([1912, 6, 23], date.civil)
+    assert_equal([1912, 6, 23], date.instance_variable_get(:@__civil__))
+  end
+
+  def test_sys_strftime
+    date = Date.new(1912, 6, 23)
+    assert_equal "1912-06-23", date.sys_strftime
+    assert_equal "06/23/1912", date.sys_strftime("%m/%d/%Y")
+  end
+
+  def test_sys_strptime
+    assert_equal Date.new(1912, 6, 23), Date.sys_strptime("1912-06-23")
+    assert_equal Date.new(1912, 6, 23), Date.sys_strptime("1912-06-23", "%Y-%m-%d")
+  end
+
+  # This falls back on Ruby's strptime on BSD systems because BSD's strptime doesn't
+  # handle years before 1900.
+  def test_strptime_fallback
+    assert_equal Date.new(1, 1, 1), Date.strptime("01/01/0001", "%m/%d/%Y")
+  end
+
+  # Make sure we're not breaking DateTime
+  def test_datetime
+    datetime = DateTime.parse("1912-06-23T04:20:37Z")
+    assert_equal 1912, datetime.year
+    assert_equal 6, datetime.month
+    assert_equal 23, datetime.day
+    assert_equal 4, datetime.hour
+    assert_equal 20, datetime.min
+    assert_equal 37, datetime.sec
+  end
+
+  def test_new_fails_with_nils
+    assert_raise(TypeError) { Date.new(nil, nil, nil) }
+    assert_raise(TypeError) { Date.new(2007, nil, nil) }
+    assert_raise(TypeError) { Date.new(2007, 9, nil) }
+  end
+
+  def test_strftime_with_weekday
+    assert_equal "Monday", Date.new(2007, 1, 1).strftime("%A")
+  end
+
+  def test_strftime_with_datetime
+    dt = DateTime.new(2007, 1, 1, 4, 20, 00)
+    assert_equal "2007-01-01T04:20:00+00:00", dt.strftime("%FT%T%:z")
+  end
+
+  def test_constructor_with_negative_days
+    #leap year
+    month_ends = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    (1..12).each do |m|
+      d = Date.new(2008, m, -1)
+      assert_equal d.day, month_ends[m-1]
+    end
+    #normal year
+    month_ends = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    (1..12).each do |m|
+      d = Date.new(2009, m, -1)
+      assert_equal d.day, month_ends[m-1]
+    end
+    #before calendar reform for Italy
+    month_ends = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    (1..12).each do |m|
+      d = Date.new(1581, m, -1)
+      assert_equal d.day, month_ends[m-1]
+    end
+  end
+
+  def test_date_comparisons
+    #regular Date class comparison
+    d = Date.new(2008, 1, 1)
+    366.times do |i|
+        assert_equal( 0, d+i <=> d+i )
+        assert_equal(-1, d+i <=> d+i+1 )
+        assert_equal( 1, d+i+1 <=> d+i )
+    end
+
+    #DateTime comparison
+    dt1 = DateTime.new(2006,1,1,12,15,30)
+    dt2 = DateTime.new(2006,1,1,12,15,31)
+    dt3 = DateTime.new(2006,1,1,12,15,29)
+ 
+    assert_equal( 0, DateTime.new(2006,1,1,12,15,30) <=> dt1 )
+    assert_equal( 1, dt1 <=> dt3 )
+    assert_equal( -1, dt1 <=> dt2 )
+
+    #comparison with some random type
+    assert_equal nil, dt1 <=> "foo"
+
+    #comparison with Fixnum that represents ajd
+    assert_equal(-1, d <=> d.ajd.numerator )
+  end
+
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: seamusabshere-date-performance
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ryan Tomayko
+- Alexander Dymo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Adds some semblance of performance to Ruby's core Date class.
+email: Ryan Tomayko <r@tomayko.com>
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- AUTHORS
+- BENCHMARKS
+- README.md
+- Rakefile
+- VERSION.yml
+- ext/date_performance.c
+- ext/extconf.rb
+- lib/date/memoize.rb
+- lib/date/performance.rb
+- test/benchmarks.rb
+- test/date_memoize_test.rb
+- test/extension_test.rb
+has_rdoc: true
+homepage: http://tomayko.com/src/date-performance/
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Adds some semblance of performance to Ruby's core Date class.
+test_files: 
+- test/benchmarks.rb
+- test/date_memoize_test.rb
+- test/extension_test.rb