# date2.rb: Written by Tadayoshi Funaba 1998-2001
# $Id: date.rb,v 1.1.1.1 2002/05/27 17:59:48 jkh Exp $
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)
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
end
def 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
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
end
def ordinal_to_jd(y, d, sg=GREGORIAN)
civil_to_jd(y, 1, d, sg)
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
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 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 clfloor(x, y=1)
q, r = x.divmod(y)
q = q.to_i
return q, r
end
def rjd_to_jd(rjd) clfloor(rjd + 0.5) end
def jd_to_rjd(jd, fr) jd + fr - 0.5 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 jd_to_wday(jd) (jd + 1) % 7 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
alias_method :leap?, :gregorian_leap?
alias_method :new0, :new
def new1(jd=0, sg=ITALY) new0(jd, sg) 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
end
alias_method :exist?, :exist3?
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)
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
end
def new2(y=-4712, d=1, sg=ITALY)
unless jd = exist2?(y, d, sg)
raise ArgumentError, 'invalid date'
end
new0(jd, 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
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)
end
def today(sg=ITALY)
new0(civil_to_jd(*(Time.now.to_a[3..5].reverse << sg)), sg)
end
def once(*ids)
for id in ids
module_eval <<-"end;"
alias_method :__#{id.to_i}__, :#{id.id2name}
private :__#{id.to_i}__
def #{id.id2name}(*args, &block)
(@__#{id.to_i}__ ||= [__#{id.to_i}__(*args, &block)])[0]
end
end;
end
end
private :once
end
def initialize(rjd=0, sg=ITALY) @rjd, @sg = rjd, sg end
def rjd() @rjd end
def rmjd() type.jd_to_mjd(@rjd) end
def rtjd() type.jd_to_tjd(@rjd) end
def rtjd2() type.jd_to_tjd2(@rjd) end
once :rmjd, :rtjd, :rtjd2
def jd() type.rjd_to_jd(@rjd)[0] end
def fr1() type.rjd_to_jd(@rjd)[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
def civil() type.jd_to_civil(jd, @sg) end
def ordinal() type.jd_to_ordinal(jd, @sg) end
def commercial() type.jd_to_commercial(jd, @sg) end
once :civil, :ordinal, :commercial
private :civil, :ordinal, :commercial
def year() civil[0] end
def yday() ordinal[1] end
def mon() civil[1] end
alias_method :month, :mon
def mday() civil[2] end
alias_method :day, :mday
def cwyear() commercial[0] end
def cweek() commercial[1] end
def cwday() commercial[2] end
def wday() type.jd_to_wday(jd) end
once :wday
def os? () type.os?(jd, @sg) end
def ns? () type.ns?(jd, @sg) end
once :os?, :ns?
def leap?
type.jd_to_civil(type.civil_to_jd(year, 3, 1, ns?) - 1,
ns?)[-1] == 29
end
once :leap?
def sg() @sg end
def newsg(sg=type::ITALY) type.new0(@rjd, sg) end
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 + (n)
case n
when Numeric; return type.new0(@rjd + n, @sg)
end
raise TypeError, 'expected numeric'
end
def - (x)
case x
when Numeric; return type.new0(@rjd - x, @sg)
when Date; return @rjd - x.rjd
end
raise TypeError, 'expected numeric or date'
end
def <=> (other)
case other
when Numeric; return @rjd <=> other
when Date; return @rjd <=> other.rjd
end
raise TypeError, 'expected numeric or date'
end
def === (other)
case other
when Numeric; return jd == other
when Date; return jd == other.jd
end
raise TypeError, 'expected numeric or date'
end
def >> (n)
y, m = type.clfloor(year * 12 + (mon - 1) + n, 12)
m, = type.clfloor(m + 1, 1)
d = mday
d -= 1 until jd2 = type.exist3?(y, m, d, ns?)
self + (jd2 - jd)
end
def << (n) self >> -n end
def step(limit, step)
da = self
op = [:-,:<=,:>=][step<=>0]
while da.__send__(op, limit)
yield da
da += step
end
self
end
def upto(max, &block) step(max, +1, &block) end
def downto(min, &block) step(min, -1, &block) end
def succ() self + 1 end
alias_method :next, :succ
def eql? (other) Date === other and self == other end
def hash() type.clfloor(@rjd)[0] end
def inspect() format('#<%s: %s,%s>', type, @rjd, @sg) end
def to_s() format('%.4d-%02d-%02d', year, mon, mday) end
def _dump(limit) Marshal.dump([@rjd, @sg], -1) end
def self._load(str) new0(*Marshal.load(str)) end
end