Date

 
               # File date.rb, line 1355
def self._load(str)
  a = Marshal.load(str)
  if a.size == 2
    ajd,     sg = a
         of = 0
    ajd -= 1.to_r/2
  else
    ajd, of, sg = a
  end
  new!(ajd, of, sg)
end
            

 
               # File date/format.rb, line 958
def self._parse(str, comp=false)
  str = str.dup

  e = Format::Bag.new

  e._comp = comp

  str.gsub!(/[^-+',.\/:0-9@a-z\x80-\xff]+/in, ' ')

  _parse_time(str, e) # || _parse_beat(str, e)
  _parse_day(str, e)

  _parse_eu(str, e)     ||
  _parse_us(str, e)     ||
  _parse_iso(str, e)    ||
  _parse_jis(str, e)    ||
  _parse_vms(str, e)    ||
  _parse_sla_us(str, e) ||
  _parse_iso2(str, e)   ||
  _parse_year(str, e)   ||
  _parse_mon(str, e)    ||
  _parse_mday(str, e)   ||
  _parse_ddd(str, e)

  if str.sub!(/\b(bc\b|bce\b|b\.c\.|b\.c\.e\.)/in, ' ')
    if e.year
      e.year = -e.year + 1
    end
  end

  if str.sub!(/\A\s*(\d{1,2})\s*\z/n, ' ')
    if e.hour && !e.mday
      v = $1.to_i
      if (1..31) === v
        e.mday = v
      end
    end
    if e.mday && !e.hour
      v = $1.to_i
      if (0..24) === v
        e.hour = v
      end
    end
  end

  if e._comp and e.year
    if e.year >= 0 and e.year <= 99
      if e.year >= 69
        e.year += 1900
      else
        e.year += 2000
      end
    end
  end

  e.offset ||= zone_to_diff(e.zone) if e.zone

  e.to_hash
end
            

 
               # File date/format.rb, line 581
def self._strptime(str, fmt='%F')
  e = Format::Bag.new
  return unless _strptime_i(str.dup, fmt, e)

  if e._cent
    if e.cwyear
      e.cwyear += e._cent * 100
    end
    if e.year
      e.  year += e._cent * 100
    end
  end

  if e._merid
    if e.hour
      e.hour %= 12
      e.hour += e._merid
    end
  end

  e.to_hash
end
            

 
               # File date.rb, line 513
def self.ajd_to_amjd(ajd) ajd - 4800001.to_r/2 end
            

 
               # File date.rb, line 479
def self.ajd_to_jd(ajd, of=0) (ajd + of + 1.to_r/2).divmod(1) end
            

 
               # File date.rb, line 509
def self.amjd_to_ajd(amjd) amjd + 4800001.to_r/2 end
            

 
               # File date.rb, line 725
def self.civil(y=-4712, m=1, d=1, sg=ITALY)
  unless jd = valid_civil?(y, m, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end
            

 
               # File date.rb, line 383
def self.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 julian?(jd, sg)
    jd -= b
  end
  jd
end
            

 
               # File date.rb, line 748
def self.commercial(y=1582, w=41, d=5, sg=ITALY)
  unless jd = valid_commercial?(y, w, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end
            

 
               # File date.rb, line 432
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
            

 
               # File date.rb, line 494
def self.day_fraction_to_time(fr)
  h,   fr = fr.divmod(1.to_r/24)
  min, fr = fr.divmod(1.to_r/1440)
  s,   fr = fr.divmod(1.to_r/86400)
  return h, min, s, fr
end
            

 
               # File date.rb, line 345
def self.gregorian? (jd, sg) !julian?(jd, sg) end
            

 
               # File date.rb, line 545
def self.gregorian_leap? (y) y % 4 == 0 && y % 100 != 0 || y % 400 == 0 end
            

 
               # File date.rb, line 690
def self.jd(jd=0, sg=ITALY)
  jd = valid_jd?(jd, sg)
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end
            

 
               # File date.rb, line 490
def self.jd_to_ajd(jd, fr, of=0) jd + fr - of - 1.to_r/2 end
            

 
               # File date.rb, line 405
def self.jd_to_civil(jd, sg=GREGORIAN)
  if julian?(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
            

 
               # File date.rb, line 446
def self.jd_to_commercial(jd, sg=GREGORIAN)
  ns = fix_style(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).floor
  d = (jd + 1) % 7
  d = 7 if d == 0
  return y, w, d
end
            

 
               # File date.rb, line 529
def self.jd_to_ld(jd) jd - 2299160 end
            

 
               # File date.rb, line 521
def self.jd_to_mjd(jd) jd - 2400001 end
            

 
               # File date.rb, line 372
def self.jd_to_ordinal(jd, sg=GREGORIAN)
  y = jd_to_civil(jd, sg)[0]
  doy = jd - civil_to_jd(y - 1, 12, 31, fix_style(jd, sg))
  return y, doy
end
            

 
               # File date.rb, line 534
def self.jd_to_wday(jd) (jd + 1) % 7 end
            

 
               # File date.rb, line 327
  def self.julian? (jd, sg)
    case sg
    when Numeric
      jd < sg
    else
      if $VERBOSE
        warn("#{caller.shift.sub(/:in .*/, '')}: " \
"warning: do not use non-numerical object as julian day number anymore")
      end
      not sg
    end
  end
            

 
               # File date.rb, line 539
def self.julian_leap? (y) y % 4 == 0 end
            

 
               # File date.rb, line 525
def self.ld_to_jd(ld) ld + 2299160 end
            

 
               # File date.rb, line 517
def self.mjd_to_jd(mjd) mjd + 2400001 end
            

 
               # File date.rb, line 1015
def initialize(ajd=0, of=0, sg=ITALY) @ajd, @of, @sg = ajd, of, sg end
            

 
               # File date.rb, line 705
def self.ordinal(y=-4712, d=1, sg=ITALY)
  unless jd = valid_ordinal?(y, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end
            

 
               # File date.rb, line 361
def self.ordinal_to_jd(y, d, sg=GREGORIAN)
  civil_to_jd(y, 1, d, sg)
end
            

 
               # File date.rb, line 973
def self.parse(str='-4712-01-01', comp=false, sg=ITALY)
  elem = _parse(str, comp)
  new_by_frags(elem, sg)
end
            

 
               # File date.rb, line 953
def self.strptime(str='-4712-01-01', fmt='%F', sg=ITALY)
  elem = _strptime(str, fmt)
  new_by_frags(elem, sg)
end
            

 
               # File date.rb, line 503
def self.time_to_day_fraction(h, min, s)
  h.to_r/24 + min.to_r/1440 + s.to_r/86400
end
            

 
               # File date.rb, line 1626
def self.today(sg=ITALY)
  t = Time.now
  jd = civil_to_jd(t.year, t.mon, t.mday, sg)
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end
            

 
               # File date.rb, line 595
def self.valid_civil? (y, m, d, sg=ITALY)
  if m < 0
    m += 13
  end
  if d < 0
    ny, nm = (y * 12 + m).divmod(12)
    nm,    = (nm + 1).divmod(1)
    jd = civil_to_jd(ny, nm, d + 1, sg)
    ns = fix_style(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
            

 
               # File date.rb, line 629
def self.valid_commercial? (y, w, d, sg=ITALY)
  if d < 0
    d += 8
  end
  if w < 0
    ny, nw, nd =
      jd_to_commercial(commercial_to_jd(y + 1, 1, 1) + w * 7)
    return unless ny == y
    w = nw
  end
  jd = commercial_to_jd(y, w, d)
  return unless gregorian?(jd, sg)
  return unless [y, w, d] == jd_to_commercial(jd)
  jd
end
            

 
               # File date.rb, line 554
def self.valid_jd? (jd, sg=ITALY) jd end
            

 
               # File date.rb, line 569
def self.valid_ordinal? (y, d, sg=ITALY)
  if d < 0
    ny, = (y + 1).divmod(1)
    jd = ordinal_to_jd(ny, d + 1, sg)
    ns = fix_style(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
            

 
               # File date.rb, line 672
def self.valid_time? (h, min, s)
  h   += 24 if h   < 0
  min += 60 if min < 0
  s   += 60 if s   < 0
  return unless ((0..23) === h &&
                 (0..59) === min &&
                 (0..59) === s) ||
                (24 == h &&
                  0 == min &&
                  0 == s)
  time_to_day_fraction(h, min, s)
end
            

 
               # File date.rb, line 1200
def + (n)
  case n
  when Numeric; return self.class.new!(@ajd + n, @of, @sg)
  end
  raise TypeError, 'expected numeric'
end
            

 
               # File date.rb, line 1215
def - (x)
  case x
  when Numeric; return self.class.new!(@ajd - x, @of, @sg)
  when Date;    return @ajd - x.ajd
  end
  raise TypeError, 'expected numeric or date'
end
            

 
               # File date.rb, line 1290
def << (n) self >> -n end
            

 
               # File date.rb, line 1234
def <=> (other)
  case other
  when Numeric; return @ajd <=> other
  when Date;    return @ajd <=> other.ajd
  end
  nil
end
            

 
               # File date.rb, line 1248
def === (other)
  case other
  when Numeric; return jd == other
  when Date;    return jd == other.jd
  end
  false
end
            

 
               # File date.rb, line 1272
def >> (n)
  y, m = (year * 12 + (mon - 1) + n).divmod(12)
  m,   = (m + 1)                    .divmod(1)
  d = mday
  until jd2 = self.class.valid_civil?(y, m, d, fix_style)
    d -= 1
    raise ArgumentError, 'invalid date' unless d > 0
  end

  self + (jd2 - jd)
end
            

 
               # File date.rb, line 1350
def _dump(limit) Marshal.dump([@ajd, @of, @sg], -1) end
            

 
               # File date.rb, line 1018
def ajd() @ajd end
            

 
               # File date.rb, line 1021
def amjd() self.class.ajd_to_amjd(@ajd) end
            

 
               # File date/format.rb, line 336
def asctime() strftime('%c') end
            

 
               # File date.rb, line 1114
def cwday() commercial[2] end
            

 
               # File date.rb, line 1110
def cweek() commercial[1] end
            

 
               # File date.rb, line 1107
def cwyear() commercial[0] end
            

 
               # File date.rb, line 1029
def day_fraction() self.class.ajd_to_jd(@ajd, @of)[1] end
            

 
               # File date.rb, line 1329
def downto(min, &block) # :yield: date
  step(min, -1, &block)
end
            

 
               # File date.rb, line 1170
def england() new_start(self.class::ENGLAND) end
            

 
               # File date.rb, line 1336
def eql? (other) Date === other && self == other end
            

 
               # File date.rb, line 1178
def gregorian() new_start(self.class::GREGORIAN) end
            

 
               # File date.rb, line 1138
def gregorian? () self.class.gregorian?(jd, @sg) end
            

 
               # File date.rb, line 1339
def hash() @ajd.hash end
            

 
               # File date.rb, line 1087
def hour() time[0] end
            

 
               # File date.rb, line 1342
def inspect() format('#<%s: %s,%s,%s>', self.class, @ajd, @of, @sg) end
            

 
               # File date.rb, line 1166
def italy() new_start(self.class::ITALY) end
            

 
               # File date.rb, line 1026
def jd() self.class.ajd_to_jd(@ajd, @of)[0] end
            

 
               # File date.rb, line 1174
def julian() new_start(self.class::JULIAN) end
            

 
               # File date.rb, line 1135
def julian? () self.class.julian?(jd, @sg) end
            

 
               # File date.rb, line 1036
def ld() self.class.jd_to_ld(jd) end
            

 
               # File date.rb, line 1151
def leap?
  self.class.jd_to_civil(self.class.civil_to_jd(year, 3, 1, fix_style) - 1,
                   fix_style)[-1] == 29
end
            

 
               # File date.rb, line 1069
def mday() civil[2] end
            

 
               # File date.rb, line 1090
def min() time[1] end
            

 
               # File date.rb, line 1032
def mjd() self.class.jd_to_mjd(jd) end
            

 
               # File date.rb, line 1066
def mon() civil[1] end
            

 
               # File date.rb, line 1182
def new_offset(of=0)
  if String === of
    of = (self.class.zone_to_diff(of) || 0).to_r/86400
  end
  self.class.new!(@ajd, of, @sg)
end
            

 
               # File date.rb, line 1162
def new_start(sg=self.class::ITALY) self.class.new!(@ajd, @of, sg) end
            

 
               # File date.rb, line 1262
def next() next_day end
            

 
               # File date.rb, line 1180
def offset() @of end
            

 
               # File date.rb, line 1093
def sec() time[2] end
            

 
               # File date.rb, line 1097
def sec_fraction() time[3] end
            

 
               # File date.rb, line 1159
def start() @sg end
            

 
               # File date.rb, line 1306
  def step(limit, step=1) # :yield: date
=begin
    unless block_given?
      return to_enum(:step, limit, step)
    end
=end
    da = self
    op = %w(- <= >=)[step <=> 0]
    while da.__send__(op, limit)
      yield da
      da += step
    end
    self
  end
            

 
               # File date/format.rb, line 200
def strftime(fmt='%F')
  fmt.gsub(/%([-_0^#]+)?(\d+)?[EO]?(:{1,3}z|.)/m) do |m|
    f = {}
    s, w, c = $1, $2, $3
    if s
      s.scan(/./) do |k|
        case k
        when '-'; f[:p] = '-'
        when '_'; f[:p] = "\s"
        when '0'; f[:p] = '0'
        when '^'; f[:u] = true
        when '#'; f[:x] = true
        end
      end
    end
    if w
      f[:w] = w.to_i
    end
    case c
    when 'A'; emit_ad(DAYNAMES[wday], 0, f)
    when 'a'; emit_ad(ABBR_DAYNAMES[wday], 0, f)
    when 'B'; emit_ad(MONTHNAMES[mon], 0, f)
    when 'b'; emit_ad(ABBR_MONTHNAMES[mon], 0, f)
    when 'C'; emit_sn((year / 100).floor, 2, f)
    when 'c'; emit_a(strftime('%a %b %e %H:%M:%S %Y'), 0, f)
    when 'D'; emit_a(strftime('%m/%d/%y'), 0, f)
    when 'd'; emit_n(mday, 2, f)
    when 'e'; emit_a(mday, 2, f)
    when 'F'
      if m == '%F'
        format('%.4d-%02d-%02d', year, mon, mday) # 4p
      else
        emit_a(strftime('%Y-%m-%d'), 0, f)
      end
    when 'G'; emit_sn(cwyear, 4, f)
    when 'g'; emit_n(cwyear % 100, 2, f)
    when 'H'; emit_n(hour, 2, f)
    when 'h'; emit_ad(strftime('%b'), 0, f)
    when 'I'; emit_n((hour % 12).nonzero? || 12, 2, f)
    when 'j'; emit_n(yday, 3, f)
    when 'k'; emit_a(hour, 2, f)
    when 'L'
      emit_n((sec_fraction / (1.to_r/86400/(10**3))).floor, 3, f)
    when 'l'; emit_a((hour % 12).nonzero? || 12, 2, f)
    when 'M'; emit_n(min, 2, f)
    when 'm'; emit_n(mon, 2, f)
    when 'N'
      emit_n((sec_fraction / (1.to_r/86400/(10**9))).floor, 9, f)
    when 'n'; "\n"
    when 'P'; emit_ad(strftime('%p').downcase, 0, f)
    when 'p'; emit_au(if hour < 12 then 'AM' else 'PM' end, 0, f)
    when 'Q'
      d = ajd - self.class.jd_to_ajd(self.class::UNIXEPOCH, 0)
      s = (d * 86400*10**3).to_i
      emit_sn(s, 1, f)
    when 'R'; emit_a(strftime('%H:%M'), 0, f)
    when 'r'; emit_a(strftime('%I:%M:%S %p'), 0, f)
    when 'S'; emit_n(sec, 2, f)
    when 's'
      d = ajd - self.class.jd_to_ajd(self.class::UNIXEPOCH, 0)
      s = (d * 86400).to_i
      emit_sn(s, 1, f)
    when 'T'
      if m == '%T'
        format('%02d:%02d:%02d', hour, min, sec) # 4p
      else
        emit_a(strftime('%H:%M:%S'), 0, f)
      end
    when 't'; "\t"
    when 'U', 'W'
      emit_n(if c == 'U' then wnum0 else wnum1 end, 2, f)
    when 'u'; emit_n(cwday, 1, f)
    when 'V'; emit_n(cweek, 2, f)
    when 'v'; emit_a(strftime('%e-%b-%Y'), 0, f)
    when 'w'; emit_n(wday, 1, f)
    when 'X'; emit_a(strftime('%H:%M:%S'), 0, f)
    when 'x'; emit_a(strftime('%m/%d/%y'), 0, f)
    when 'Y'; emit_sn(year, 4, f)
    when 'y'; emit_n(year % 100, 2, f)
    when 'Z'; emit_au(strftime('%:z'), 0, f)
    when /\A(:{0,3})z/
      t = $1.size
      sign = if offset < 0 then -1 else +1 end
      fr = offset.abs
      hh, fr = fr.divmod(1.to_r/24)
      mm, fr = fr.divmod(1.to_r/1440)
      ss, fr = fr.divmod(1.to_r/86400)
      if t == 3
        if    ss.nonzero? then t =  2
        elsif mm.nonzero? then t =  1
        else                   t = -1
        end
      end
      case t
      when -1
        tail = []
        sep = ''
      when 0
        f[:w] -= 2 if f[:w]
        tail = ['%02d' % mm]
        sep = ''
      when 1
        f[:w] -= 3 if f[:w]
        tail = ['%02d' % mm]
        sep = ':'
      when 2
        f[:w] -= 6 if f[:w]
        tail = ['%02d' % mm, '%02d' % ss]
        sep = ':'
      end
      ([emit_z(sign * hh, 2, f)] + tail).join(sep)
    when '%'; emit_a('%', 0, f)
    when '+'; emit_a(strftime('%a %b %e %H:%M:%S %Z %Y'), 0, f)
    when '1'
      if $VERBOSE
        warn("warning: strftime: %1 is deprecated; forget this")
      end
      emit_n(jd, 1, f)
    when '2'
      if $VERBOSE
        warn("warning: strftime: %2 is deprecated; use '%Y-%j'")
      end
      emit_a(strftime('%Y-%j'), 0, f)
    when '3'
      if $VERBOSE
        warn("warning: strftime: %3 is deprecated; use '%F'")
      end
      emit_a(strftime('%F'), 0, f)
    else
      c
    end
  end
end
            

 
               # File date.rb, line 1347
def to_s() strftime end
            

 
               # File date.rb, line 1323
def upto(max, &block) # :yield: date
  step(max, +1, &block)
end
            

 
               # File date.rb, line 1118
def wday() self.class.jd_to_wday(jd) end
            

 
               # File date.rb, line 1061
def yday() ordinal[1] end
            

 
               # File date.rb, line 1056
def year() civil[0] end
            

 
               # File date.rb, line 1101
def zone() strftime('%:z') end