From dc9cd6a8c22ad04baa7498fd0cbc5d519ed73be0 Mon Sep 17 00:00:00 2001 From: tadf Date: Sat, 18 May 2002 12:41:51 +0000 Subject: updated to the new version (based on date2 3.2.1). git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2467 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- lib/date.rb | 513 +++++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 351 insertions(+), 162 deletions(-) (limited to 'lib/date.rb') diff --git a/lib/date.rb b/lib/date.rb index 3422121298..3a5ad9447a 100644 --- a/lib/date.rb +++ b/lib/date.rb @@ -1,200 +1,258 @@ -# date2.rb: Written by Tadayoshi Funaba 1998-2001 -# $Id: date2.rb,v 1.23 2001-01-18 12:09:47+09 tadf Exp $ +# date.rb: Written by Tadayoshi Funaba 1998-2002 +# $Id: date.rb,v 2.6 2002-05-14 07:43:18+09 tadf Exp $ + +require 'rational' +require 'date/format' class Date include Comparable - IDENT = 2 - MONTHNAMES = [nil] + %w(January February March April May June July August September October November December) DAYNAMES = %w(Sunday Monday Tuesday Wednesday Thursday Friday Saturday) + ABBR_MONTHNAMES = [nil] + %w(Jan Feb Mar Apr May Jun + Jul Aug Sep Oct Nov Dec) + + ABBR_DAYNAMES = %w(Sun Mon Tue Wed Thu Fri Sat) + ITALY = 2299161 # 1582-10-15 ENGLAND = 2361222 # 1752-09-14 JULIAN = false GREGORIAN = true - class << self - - def os? (jd, sg) - case sg - when Numeric; jd < sg - else; not sg - end + def self.os? (jd, sg) + case sg + when Numeric; jd < sg + else; not sg end + end - def ns? (jd, sg) not os?(jd, sg) end + def self.ns? (jd, sg) not os?(jd, sg) end - def civil_to_jd(y, m, d, sg=GREGORIAN) - if m <= 2 - y -= 1 - m += 12 - end - a = (y / 100.0).floor - b = 2 - a + (a / 4.0).floor - jd = (365.25 * (y + 4716)).floor + - (30.6001 * (m + 1)).floor + - d + b - 1524 - if os?(jd, sg) - jd -= b - end - jd + def self.civil_to_jd(y, m, d, sg=GREGORIAN) + if m <= 2 + y -= 1 + m += 12 end - - def jd_to_civil(jd, sg=GREGORIAN) - if os?(jd, sg) - a = jd - else - x = ((jd - 1867216.25) / 36524.25).floor - a = jd + 1 + x - (x / 4.0).floor - end - b = a + 1524 - c = ((b - 122.1) / 365.25).floor - d = (365.25 * c).floor - e = ((b - d) / 30.6001).floor - dom = b - d - (30.6001 * e).floor - if e <= 13 - m = e - 1 - y = c - 4716 - else - m = e - 13 - y = c - 4715 - end - return y, m, dom + a = (y / 100.0).floor + b = 2 - a + (a / 4.0).floor + jd = (365.25 * (y + 4716)).floor + + (30.6001 * (m + 1)).floor + + d + b - 1524 + if os?(jd, sg) + jd -= b end + jd + end - def ordinal_to_jd(y, d, sg=GREGORIAN) - civil_to_jd(y, 1, d, sg) + def self.jd_to_civil(jd, sg=GREGORIAN) + if os?(jd, sg) + a = jd + else + x = ((jd - 1867216.25) / 36524.25).floor + a = jd + 1 + x - (x / 4.0).floor end - - def jd_to_ordinal(jd, sg=GREGORIAN) - y = jd_to_civil(jd, sg)[0] - doy = jd - civil_to_jd(y - 1, 12, 31, ns?(jd, sg)) - return y, doy + b = a + 1524 + c = ((b - 122.1) / 365.25).floor + d = (365.25 * c).floor + e = ((b - d) / 30.6001).floor + dom = b - d - (30.6001 * e).floor + if e <= 13 + m = e - 1 + y = c - 4716 + else + m = e - 13 + y = c - 4715 end + return y, m, dom + end - def jd_to_commercial(jd, sg=GREGORIAN) - ns = ns?(jd, sg) - a = jd_to_civil(jd - 3, ns)[0] - y = if jd >= commercial_to_jd(a + 1, 1, 1, ns) then a + 1 else a end - w = 1 + (jd - commercial_to_jd(y, 1, 1, ns)) / 7 - d = (jd + 1) % 7 - if d.zero? then d = 7 end - return y, w, d - end + def self.ordinal_to_jd(y, d, sg=GREGORIAN) + civil_to_jd(y, 1, d, sg) + end - def commercial_to_jd(y, w, d, ns=GREGORIAN) - jd = civil_to_jd(y, 1, 4, ns) - (jd - (((jd - 1) + 1) % 7)) + - 7 * (w - 1) + - (d - 1) - end + def self.jd_to_ordinal(jd, sg=GREGORIAN) + y = jd_to_civil(jd, sg)[0] + doy = jd - civil_to_jd(y - 1, 12, 31, ns?(jd, sg)) + return y, doy + end - def clfloor(x, y=1) - q, r = x.divmod(y) - q = q.to_i - return q, r - end + def self.jd_to_commercial(jd, sg=GREGORIAN) + ns = ns?(jd, sg) + a = jd_to_civil(jd - 3, ns)[0] + y = if jd >= commercial_to_jd(a + 1, 1, 1, ns) then a + 1 else a end + w = 1 + (jd - commercial_to_jd(y, 1, 1, ns)) / 7 + d = (jd + 1) % 7 + if d.zero? then d = 7 end + return y, w, d + end - def rjd_to_jd(rjd) clfloor(rjd + 0.5) end - def jd_to_rjd(jd, fr) jd + fr - 0.5 end + def self.commercial_to_jd(y, w, d, ns=GREGORIAN) + jd = civil_to_jd(y, 1, 4, ns) + (jd - (((jd - 1) + 1) % 7)) + + 7 * (w - 1) + + (d - 1) + end - def mjd_to_jd(mjd) mjd + 2400000.5 end - def jd_to_mjd(jd) jd - 2400000.5 end - def tjd_to_jd(tjd) tjd + 2440000.5 end - def jd_to_tjd(jd) jd - 2440000.5 end - def tjd2_to_jd(cycle, tjd) tjd_to_jd(cycle * 10000 + tjd) end - def jd_to_tjd2(jd) clfloor(jd_to_tjd(jd), 10000) end - def ld_to_jd(ld) ld + 2299160 end - def jd_to_ld(jd) jd - 2299160 end + def self.clfloor(x, y=1) + q, r = x.divmod(y) + q = q.to_i + return q, r + end - def jd_to_wday(jd) (jd + 1) % 7 end + def self.rjd_to_jd(rjd, of=0) clfloor(rjd + of + 1.to_r/2) end + def self.jd_to_rjd(jd, fr, of=0) jd + fr - of - 1.to_r/2 end - def julian_leap? (y) y % 4 == 0 end - def gregorian_leap? (y) y % 4 == 0 and y % 100 != 0 or y % 400 == 0 end + def self.day_fraction_to_time(fr) + h, fr = clfloor(fr, 1.to_r/24) + min, fr = clfloor(fr, 1.to_r/1440) + s, fr = clfloor(fr, 1.to_r/86400) + return h, min, s, fr + end - alias_method :leap?, :gregorian_leap? + def self.time_to_day_fraction(h, min, s) + h.to_r/24 + min.to_r/1440 + s.to_r/86400 + end - alias_method :new0, :new + def self.mjd_to_jd(mjd) mjd + 4800001.to_r/2 end + def self.jd_to_mjd(jd) jd - 4800001.to_r/2 end + def self.tjd_to_jd(tjd) tjd + 4880001.to_r/2 end + def self.jd_to_tjd(jd) jd - 4880001.to_r/2 end + def self.tjd2_to_jd(cycle, tjd) tjd_to_jd(cycle * 10000 + tjd) end + def self.jd_to_tjd2(jd) clfloor(jd_to_tjd(jd), 10000) end + def self.ld_to_jd(ld) ld + 2299160 end + def self.jd_to_ld(jd) jd - 2299160 end - def new1(jd=0, sg=ITALY) new0(jd, sg) end + def self.jd_to_wday(jd) (jd + 1) % 7 end - def exist3? (y, m, d, sg=ITALY) - if m < 0 - m += 13 - end - if d < 0 - ny, nm = clfloor(y * 12 + m, 12) - nm, = clfloor(nm + 1, 1) - jd = civil_to_jd(ny, nm, d + 1, sg) - ns = ns?(jd, sg) - return unless [y, m] == jd_to_civil(jd, sg)[0..1] - return unless [ny, nm, 1] == jd_to_civil(jd - d, ns) - else - jd = civil_to_jd(y, m, d, sg) - return unless [y, m, d] == jd_to_civil(jd, sg) - end - jd + def self.julian_leap? (y) y % 4 == 0 end + def self.gregorian_leap? (y) y % 4 == 0 and y % 100 != 0 or y % 400 == 0 end + + class << self; alias_method :leap?, :gregorian_leap? end + class << self; alias_method :new0, :new end + + def self.exist1? (jd, sg=ITALY) jd end + + class << self; alias_method :valid_jd?, :exist1? end + + def self.new1(jd=0, sg=ITALY) + jd = exist1?(jd, sg) + new0(jd_to_rjd(jd, 0, 0), 0, sg) + end + + class << self; alias_method :jd, :new1 end + + def self.exist2? (y, d, sg=ITALY) + if d < 0 + ny, = clfloor(y + 1, 1) + jd = ordinal_to_jd(ny, d + 1, sg) + ns = ns?(jd, sg) + return unless [y] == jd_to_ordinal(jd, sg)[0..0] + return unless [ny, 1] == jd_to_ordinal(jd - d, ns) + else + jd = ordinal_to_jd(y, d, sg) + return unless [y, d] == jd_to_ordinal(jd, sg) end + jd + end - alias_method :exist?, :exist3? + class << self; alias_method :valid_ordinal?, :exist2? end - def new3(y=-4712, m=1, d=1, sg=ITALY) - unless jd = exist3?(y, m, d, sg) - raise ArgumentError, 'invalid date' - end - new0(jd, sg) + def self.new2(y=-4712, d=1, sg=ITALY) + unless jd = exist2?(y, d, sg) + raise ArgumentError, 'invalid date' end + new0(jd_to_rjd(jd, 0, 0), 0, sg) + end - alias_method :new, :new3 - - def exist2? (y, d, sg=ITALY) - if d < 0 - ny, = clfloor(y + 1, 1) - jd = ordinal_to_jd(ny, d + 1, sg) - ns = ns?(jd, sg) - return unless [y] == jd_to_ordinal(jd, sg)[0..0] - return unless [ny, 1] == jd_to_ordinal(jd - d, ns) - else - jd = ordinal_to_jd(y, d, sg) - return unless [y, d] == jd_to_ordinal(jd, sg) - end - jd + class << self; alias_method :ordinal, :new2 end + + def self.exist3? (y, m, d, sg=ITALY) + if m < 0 + m += 13 end + if d < 0 + ny, nm = clfloor(y * 12 + m, 12) + nm, = clfloor(nm + 1, 1) + jd = civil_to_jd(ny, nm, d + 1, sg) + ns = ns?(jd, sg) + return unless [y, m] == jd_to_civil(jd, sg)[0..1] + return unless [ny, nm, 1] == jd_to_civil(jd - d, ns) + else + jd = civil_to_jd(y, m, d, sg) + return unless [y, m, d] == jd_to_civil(jd, sg) + end + jd + end - def new2(y=-4712, d=1, sg=ITALY) - unless jd = exist2?(y, d, sg) - raise ArgumentError, 'invalid date' - end - new0(jd, sg) + class << self; alias_method :exist?, :exist3? end + class << self; alias_method :valid_civil?, :exist3? end + + def self.new3(y=-4712, m=1, d=1, sg=ITALY) + unless jd = exist3?(y, m, d, sg) + raise ArgumentError, 'invalid date' end + new0(jd_to_rjd(jd, 0, 0), 0, sg) + end - def existw? (y, w, d, sg=ITALY) - if d < 0 - d += 8 - end - if w < 0 - w = jd_to_commercial(commercial_to_jd(y + 1, 1, 1) + w * 7)[1] - end - jd = commercial_to_jd(y, w, d) - return unless ns?(jd, sg) - return unless [y, w, d] == jd_to_commercial(jd) - jd + class << self; alias_method :new, :new3 end + class << self; alias_method :civil, :new3 end + + def self.existw? (y, w, d, sg=ITALY) + if d < 0 + d += 8 end + if w < 0 + w = jd_to_commercial(commercial_to_jd(y + 1, 1, 1) + w * 7)[1] + end + jd = commercial_to_jd(y, w, d) + return unless ns?(jd, sg) + return unless [y, w, d] == jd_to_commercial(jd) + jd + end - def neww(y=1582, w=41, d=5, sg=ITALY) - unless jd = existw?(y, w, d, sg) - raise ArgumentError, 'invalid date' - end - new0(jd, sg) + class << self; alias_method :valid_commercial?, :existw? end + + def self.neww(y=1582, w=41, d=5, sg=ITALY) + unless jd = existw?(y, w, d, sg) + raise ArgumentError, 'invalid date' end + new0(jd_to_rjd(jd, 0, 0), 0, sg) + end - def today(sg=ITALY) - new0(civil_to_jd(*(Time.now.to_a[3..5].reverse << sg)), sg) + class << self; alias_method :commercial, :neww end + + def self.new_with_hash(elem, sg) + elem ||= {} + y, m, d = elem.select(:year, :mon, :mday) + if [y, m, d].include? nil + raise ArgumentError, 'invalid date' + else + new3(y, m, d, sg) end + end + + private_class_method :new_with_hash + + def self.strptime(str='-4712-01-01', fmt='%F', sg=ITALY) + elem = _strptime(str, fmt) + new_with_hash(elem, sg) + end + + def self.parse(str='-4712-01-01', comp=false, sg=ITALY) + elem = _parse(str, comp) + new_with_hash(elem, sg) + end + + def self.today(sg=ITALY) + jd = civil_to_jd(*(Time.now.to_a[3..5].reverse << sg)) + new0(jd_to_rjd(jd, 0, 0), 0, sg) + end + + class << self def once(*ids) for id in ids @@ -212,7 +270,7 @@ class Date end - def initialize(rjd=0, sg=ITALY) @rjd, @sg = rjd, sg end + def initialize(rjd=0, of=0, sg=ITALY) @rjd, @of, @sg = rjd, of, sg end def rjd() @rjd end def rmjd() type.jd_to_mjd(@rjd) end @@ -221,14 +279,14 @@ class Date once :rmjd, :rtjd, :rtjd2 - def jd() type.rjd_to_jd(@rjd)[0] end - def fr1() type.rjd_to_jd(@rjd)[1] end + def jd() type.rjd_to_jd(@rjd, @of)[0] end + def day_fraction() type.rjd_to_jd(@rjd, @of)[1] end def mjd() type.jd_to_mjd(jd) end def tjd() type.jd_to_tjd(jd) end def tjd2() type.jd_to_tjd2(jd) end def ld() type.jd_to_ld(jd) end - once :jd, :fr1, :mjd, :tjd, :tjd2, :ld + once :jd, :day_fraction, :mjd, :tjd, :tjd2, :ld def civil() type.jd_to_civil(jd, @sg) end def ordinal() type.jd_to_ordinal(jd, @sg) end @@ -240,12 +298,32 @@ class Date def year() civil[0] end def yday() ordinal[1] end def mon() civil[1] end + def mday() civil[2] end alias_method :month, :mon + alias_method :day, :mday - def mday() civil[2] end + def time() type.day_fraction_to_time(day_fraction) end - alias_method :day, :mday + once :time + private :time + + def hour() time[0] end + def min() time[1] end + def sec() time[2] end + def sec_fraction() time[3] end + + private :hour, :min, :sec, :sec_fraction + + def zone + ['Z', + format('%+.2d%02d', + (of / (1.to_r/24)).to_i, + (of.abs % (1.to_r/24) / (1.to_r/1440)).to_i) + ][of<=>0] + end + + private :zone def cwyear() commercial[0] end def cweek() commercial[1] end @@ -268,23 +346,34 @@ class Date once :leap? def sg() @sg end - def newsg(sg=type::ITALY) type.new0(@rjd, sg) end + def newsg(sg=type::ITALY) type.new0(@rjd, @of, sg) end + + alias_method :start, :sg + alias_method :new_start, :newsg def italy() newsg(type::ITALY) end def england() newsg(type::ENGLAND) end def julian() newsg(type::JULIAN) end def gregorian() newsg(type::GREGORIAN) end + def of() @of end + def newof(of=0) type.new0(@rjd, of, @sg) end + + alias_method :offset, :of + alias_method :new_offset, :newof + + private :of, :newof, :offset, :new_offset + def + (n) case n - when Numeric; return type.new0(@rjd + n, @sg) + when Numeric; return type.new0(@rjd + n, @of, @sg) end raise TypeError, 'expected numeric' end def - (x) case x - when Numeric; return type.new0(@rjd - x, @sg) + when Numeric; return type.new0(@rjd - x, @of, @sg) when Date; return @rjd - x.rjd end raise TypeError, 'expected numeric or date' @@ -334,12 +423,112 @@ class Date alias_method :next, :succ def eql? (other) Date === other and self == other end - def hash() type.clfloor(@rjd)[0] end + def hash() @rjd.hash end - def inspect() format('#<%s: %s,%s>', type, @rjd, @sg) end - def to_s() format('%.4d-%02d-%02d', year, mon, mday) end + def inspect() format('#<%s: %s,%s,%s>', type, @rjd, @of, @sg) end + def to_s() strftime end - def _dump(limit) Marshal.dump([@rjd, @sg], -1) end + def _dump(limit) Marshal.dump([@rjd, @of, @sg], -1) end def self._load(str) new0(*Marshal.load(str)) end end + +class DateTime < Date + + def self.existt? (h, min, s) + h += 24 if h < 0 + min += 60 if min < 0 + s += 60 if s < 0 + return unless (0..24) === h and + (0..59) === min and + (0..59) === s + time_to_day_fraction(h, min, s) + end + + class << self; alias_method :valid_time?, :existt? end + + def self.new1(jd=0, h=0, min=0, s=0, of=0, sg=ITALY) + unless (jd = exist1?(jd, sg)) and + (fr = existt?(h, min, s)) + raise ArgumentError, 'invalid date' + end + new0(jd_to_rjd(jd, fr, of), of, sg) + end + + class << self; alias_method :jd, :new1 end + + def self.new2(y=-4712, d=1, h=0, min=0, s=0, of=0, sg=ITALY) + unless (jd = exist2?(y, d, sg)) and + (fr = existt?(h, min, s)) + raise ArgumentError, 'invalid date' + end + new0(jd_to_rjd(jd, fr, of), of, sg) + end + + class << self; alias_method :ordinal, :new2 end + + def self.new3(y=-4712, m=1, d=1, h=0, min=0, s=0, of=0, sg=ITALY) + unless (jd = exist3?(y, m, d, sg)) and + (fr = existt?(h, min, s)) + raise ArgumentError, 'invalid date' + end + new0(jd_to_rjd(jd, fr, of), of, sg) + end + + class << self; alias_method :new, :new3 end + class << self; alias_method :civil, :new3 end + + def self.neww(y=1582, w=41, d=5, h=0, min=0, s=0, of=0, sg=ITALY) + unless (jd = existw?(y, w, d, sg)) and + (fr = existt?(h, min, s)) + raise ArgumentError, 'invalid date' + end + new0(jd_to_rjd(jd, fr, of), of, sg) + end + + class << self; alias_method :commercial, :neww end + + def self.new_with_hash(elem, sg) + elem ||= {} + y, m, d, h, min, s, of = + elem.select(:year, :mon, :mday, :hour, :min, :sec, :offset) + h ||= 0 + min ||= 0 + s ||= 0 + of ||= 0 + if [y, m, d].include? nil + raise ArgumentError, 'invalid date' + else + new3(y, m, d, h, min, s, of.to_r/86400, sg) + end + end + + private_class_method :new_with_hash + + def self.strptime(str='-4712-01-01T00:00:00Z', fmt='%FT%T%Z', sg=ITALY) + elem = _strptime(str, fmt) + new_with_hash(elem, sg) + end + + def self.parse(str='-4712-01-01T00:00:00Z', comp=false, sg=ITALY) + elem = _parse(str, comp) + new_with_hash(elem, sg) + end + + class << self; undef_method :today end + + def self.now(sg=ITALY) + i = Time.now + a = i.to_a[0..5].reverse + jd = civil_to_jd(*(a[0,3] << sg)) + fr = time_to_day_fraction(*(a[3,3])) + i.usec.to_r/86400000000 + d = Time.gm(*i.to_a).to_i - i.to_i + d += d / d.abs if d.nonzero? + of = (d / 60).to_r/1440 + new0(jd_to_rjd(jd, fr, of), of, sg) + end + + public :hour, :min, :sec, :sec_fraction, :zone, + :of, :newof, :offset, :new_offset + +end -- cgit v1.2.3