marsdate 1.0.9 → 1.1.3

data/lib/marsdate.rb

@@ -2,11 +2,11 @@ require 'date'
 
 class MarsDateTime
 
-  VERSION = "1.0.9"
+  VERSION = "1.1.3"
 
   include Comparable
 
-  MSEC_PER_SOL   = 88775244
+  MSEC_PER_SOL   = 88775244 # .09   # Really + 0.09
   SOLS_PER_MYEAR = 668.5921
   MSEC_PER_DAY   = 86400000
 
@@ -15,20 +15,19 @@ class MarsDateTime
   TimeStretch    = MSEC_PER_SOL/MSEC_PER_DAY.to_f
 
   Months = %w[ UNDEFINED
-               January   Gemini      February Cancer
-               March     Leo         April    Virgo 
-               May       Libra       June     Scorpio 
-               July      Sagittarius August   Capricorn 
-               September Aquarius    October  Pisces 
-               November  Aries       December Taurus ]   
+               M-January   Gemini      M-February Cancer
+               M-March     Leo         M-April    Virgo 
+               M-May       Libra       M-June     Scorpio 
+               M-July      Sagittarius M-August   Capricorn 
+               M-September Aquarius    M-October  Pisces 
+               M-November  Aries       M-December Taurus ]   
                # no month 0
 
   Week   = %w[ Sunday Monday Tuesday Wednesday Thursday Friday Saturday ]
 
   EpochMCE  = DateTime.new(1,1,21)
   EpochCE   = DateTime.new(1,1,1)
-  FudgeOffset = 67784 + 44000 + 1099 + 87 - 56
-  JulianDay1 = 1721443  # was ...24
+  JulianDay1 = 1721445   # Jan 1, 1 AD
 
   attr_reader :year, :month, :sol, :epoch_sol, :year_sol
   attr_reader :shr, :smin, :ssec    # stretched time
@@ -49,6 +48,14 @@ class MarsDateTime
     return true
   end
 
+  def self.short?(myear)  # short year
+    !leap?(myear)
+  end
+
+  def self.long?(myear)  # long year
+    leap?(myear)
+  end
+
   def self.sols_in_month(m, year)
     return 28 if m < 24
     return 25 if leap?(year)
@@ -67,7 +74,7 @@ class MarsDateTime
 
   def leaps(myr)
     n = 0
-    1.upto(myr) {|i| n+=1 if leap?(i) } 
+    1.upto(myr) {|i| n+=1 if MarsDateTime.leap?(i) } 
     n
   end
 
@@ -87,8 +94,16 @@ class MarsDateTime
     "#@day_of_week, #{Months[@month]} #@sol, #@year at #{time}"
   end
 
-  def leap?(myear)
-    MarsDateTime.leap?(myear)    # DRY
+  def leap?
+    MarsDateTime.leap?(@year)    # DRY
+  end
+
+  def short?
+    ! leap?
+  end
+
+  def long?
+    leap?
   end
 
   def month_name
@@ -108,6 +123,8 @@ class MarsDateTime
         case params.first
           when Integer, Float
             init_mems(params.first)
+          when Date
+            init_date(params.first)
           when DateTime
             init_datetime(params.first)
         else
@@ -121,13 +138,13 @@ class MarsDateTime
 
   def check_ymshms(my, mm, msol, mhr=0, mmin=0, msec=0)
     text = ""
-    text << "year #{my} is not an integer\n" unless my.is_a? Fixnum
+    text << "year #{my} is not an integer\n" unless my.is_a? Integer
     text << "month #{mm} is out of range" unless (1..24).include? mm
     text << "sol #{msol} is out of range" unless (1..28).include? msol
     text << "hour #{mhr} is out of range" unless (0..24).include? mhr
     text << "minute #{mmin} is out of range" unless (0..59).include? mmin
     text << "second #{msec} is out of range" unless (0..59).include? msec
-    if !leap?(my) && mm == 24 && msol > 24
+    if !MarsDateTime.leap?(my) && mm == 24 && msol > 24
       text << "sol #{msol} is invalid in a non-leap year" 
     end
     raise text unless text.empty?
@@ -157,10 +174,13 @@ class MarsDateTime
   end
 
   def init_mems(mems)
+    # Note: The sol length is off by 0.09 msec -- to properly fix this 
+    # will require measuring in microseconds so as to avoid floating-point math.
+    # The "round" calls below were experimental and were "mostly" successful.
     full_years = 0
     loop do
       millisec = FAKE_MSEC_PER_MYEAR
-      millisec += MSEC_PER_SOL if leap?(full_years+1)
+      millisec += MSEC_PER_SOL if MarsDateTime.leap?(full_years+1)
       break if mems < millisec
       mems -= millisec
       # puts "Subtracting #{millisec} -- one full year => #{mems}"
@@ -172,32 +192,29 @@ class MarsDateTime
     full_days, mems  = mems.divmod(MSEC_PER_SOL)
     full_hrs, mems   = mems.divmod(3_600_000)
     full_min, mems   = mems.divmod(60_000)
-    sec = mems/1000.0
 
-    my = full_years + 1      # 1-based
+    sec = mems/1000.0
+    my = full_years  + 1  # 1-based
     mm = full_months + 1
-    ms = full_days + 1
-    mhr = full_hrs           # 0-based
+    ms = full_days   + 1
+    mhr = full_hrs        # 0-based
     mmin = full_min
     msec = sec.to_i
-    frac = sec - msec        # fraction of a sec
-
-#    # check for leap year...
-#    if mm == 24
-#      max = leap?(my) ? 25 : 24
-#      diff = ms - max
-#      if diff > 0
-#        my, mm, ms = my+1, 1, diff
-#      end
-#    end
+    frac = sec - msec     # fraction of a sec
 
     init_yms(my, mm, ms, mhr, mmin, msec)
   end
 
+  def init_date(date)
+    dt = date.to_datetime
+    days = dt.jd - JulianDay1
+    secs = days*86400 + dt.hour*3600 + dt.min*60 + dt.sec
+    init_mems(secs*1000)
+  end
+
   def init_datetime(dt)
     days = dt.jd - JulianDay1
     secs = days*86400 + dt.hour*3600 + dt.min*60 + dt.sec
-    secs -= FudgeOffset
     init_mems(secs*1000)
   end
 
@@ -205,7 +222,7 @@ class MarsDateTime
     [@year, @month, @sol, @mhrs, @mmin, @msec]
   end
 
-  def -(other)
+  def -(other)  # FIXME? sols or secs?
     case other
       when MarsDateTime
         diff = @mems - other.mems
@@ -214,14 +231,14 @@ class MarsDateTime
         other = MarsDateTime.new(other)
         diff = @mems - other.mems
         diff.to_f / MSEC_PER_SOL
-      when Fixnum, Float
+      when Integer, Float
         self + (-other)
     else
       raise "Unexpected data type"
     end
   end
 
-  def +(sols)
+  def +(sols)  # FIXME? sols or secs?
     millisec = sols * MSEC_PER_SOL
     MarsDateTime.new(@mems + millisec)
   end
@@ -238,7 +255,7 @@ class MarsDateTime
   end
 
   def earth_date
-    secs = @mems/1000 + FudgeOffset
+    secs = @mems/1000
     days,secs = secs.divmod(86400)
     hrs, secs = secs.divmod(3600)
     min, secs = secs.divmod(60)
@@ -263,14 +280,14 @@ class MarsDateTime
       case piece
         when "%a"; final << @day_of_week[0..2]
         when "%A"; final << @day_of_week
-        when "%b"; final << month_name[0..2]
+        when "%b"; final << (@month.odd? ? month_name[2..4] : month_name[0..2])
         when "%B"; final << month_name
         when "%d"; final << zsol
         when "%e"; final << ('%2d' % @sol)
         when "%F"; final << "#@year-#{zmonth}-#{zsol}"
         when "%H"; final << zhh
         when "%j"; final << @year_sol.to_s
-        when "%m"; final << @month.to_s
+        when "%m"; final << zmonth  # @month.to_s
         when "%M"; final << zmm
         when "%s"; final << @msec.to_s  # was: (@mems*1000).to_i.to_s
         when "%S"; final << zss

data/test/spec/marsdate_spec.rb

@@ -0,0 +1,382 @@
+$: << "lib"
+require 'marsdate'
+
+require 'rubygems'
+require 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'pp'
+
+def my_assert(expr)
+  if !expr && block_given?
+    puts "\n--- DEBUG: "
+    yield 
+  end
+  assert(expr)
+end
+
+def my_assert_equal(e1, e2)
+  if e1 != e2 && block_given?
+    puts "\n--- DEBUG: "
+    yield 
+  end
+  assert_equal(e1, e2)
+end
+
+## experimenting...
+
+describe "Mars date 1/1/1" do
+  md = MarsDateTime.new(1,1,1)
+  it "should compute backwards to same result" do
+    assert_equal([1,1,1,0,0,0],md.ymshms)
+  end
+  it "should be a Sunday" do
+    assert_equal(0,md.dow)
+  end
+end
+
+describe "Mars date 2/3/4" do
+  md = MarsDateTime.new(2,3,4)
+  it "should compute backwards to same result" do
+    assert_equal([2,3,4,0,0,0],md.ymshms)
+  end
+end
+
+describe "Mars date 5/4/24" do
+  md = MarsDateTime.new(5,4,24)
+  it "should compute backwards to same result" do
+    assert_equal([5,4,24,0,0,0],md.ymshms)
+  end
+end
+
+describe "Mars date 1054/20/20" do
+  md = MarsDateTime.new(1054,20,20)
+  it "should compute backwards to same result" do
+    assert_equal([1054,20,20,0,0,0],md.ymshms)
+  end
+end
+
+describe "Earth date 1/1/22" do
+  ed = DateTime.new(1,1,22)
+  md = MarsDateTime.new(ed)
+  it "should be approximately M-date 1/1/1" do
+    assert_equal([1,1,1],md.ymshms[0..2])
+  end
+  it "should yield a Martian Sunday" do
+    assert_equal(md.day_of_week,"Sunday")
+  end
+end
+
+describe "Earth date May 23, 1961" do
+  e = DateTime.new(1961,5,23)
+  m = MarsDateTime.new(e)
+  it "should yield a Martian Thursday" do
+    assert_equal(m.day_of_week,"Thursday")
+  end
+end
+
+describe "Earth date May 24, 1961" do
+  e = DateTime.new(1961,5,24)
+  m = MarsDateTime.new(e)
+  it "should yield a Martian Friday" do
+    assert_equal(m.day_of_week,"Friday")
+  end
+end
+
+describe "A Martian date/time (y,m,s,h,m,s)" do
+  m = MarsDateTime.new(1043,2,15,12,34,45)
+  it "should set all its accessors properly" do
+    assert_equal(1043,m.myear)
+    assert_equal(2,m.month)
+    assert_equal(15,m.sol)
+    assert_equal(12,m.hr)
+    assert_equal(34,m.min)
+    assert_equal(45,m.sec)
+    assert_equal(4,m.dow)
+    assert_equal("Thursday",m.day_of_week)
+    assert_equal(43,m.year_sol)
+    assert_equal(696715,m.epoch_sol)
+  end
+end
+
+describe "The 2007 Martian equinox" do
+  e = DateTime.new(2007,12,9,17,20,0).new_offset(-5)
+  m = MarsDateTime.new(e)
+  m11 = MarsDateTime.new(1068,1,1)
+  it "should fall on or near 1/1 (MCE)" do
+    diff = (m11-m).abs
+    flag = diff < 1.0
+    assert(flag, "Difference: #{diff}")
+  end
+end
+
+describe "Constructing without parameters" do
+  m = MarsDateTime.new
+  e = DateTime.now
+  m2e = m.earth_date
+  it "should default to today" do
+    diff = (e-m2e).abs     # m - e doesn't work!
+    assert(diff < 1.0)
+  end
+end
+
+describe "Constructing with a DateTime" do
+  it "should convert from Gregorian to MCE" do
+    e = DateTime.new(1902,8,12,7,0,0)
+    m = MarsDateTime.new(e)
+    diff = (m.earth_date - e).abs   # days as a float
+    x = assert(diff < 1.0)
+  end
+end
+
+describe "A Martian date/time (933,1,2)" do
+  m = MarsDateTime.new(933,1,2)
+  it "should set the three obvious accessors properly" do
+    assert_equal(933,m.myear)
+    assert_equal(1,m.month)
+    assert_equal(2,m.sol)
+  end
+end
+
+describe "A Martian date/time (933,1,1)" do
+  m = MarsDateTime.new(933,1,1)
+  it "should set the three obvious accessors properly" do
+    assert_equal(933,m.myear)
+    assert_equal(1,m.month)
+    assert_equal(1,m.sol)
+  end
+end
+
+describe "The Martian date 24/25" do
+  describe "in a leap year" do
+    year = 1067
+    it "should exist" do
+      assert( MarsDateTime.leap?(year) )
+      MarsDateTime.new(year,24,25)   # may raise exception - no #wont_raise
+    end
+  end
+  describe "in a non-leap year" do
+    year = 1066
+    it "should not exist" do
+      assert( ! MarsDateTime.leap?(year) )
+      lambda { MarsDateTime.new(year,24,25) }.must_raise(RuntimeError) 
+    end
+  end
+end
+
+describe "The earth_date convertor" do
+  m = MarsDateTime.new(1,1,1)
+  it "should convert to a Gregorian date" do
+    e = m.earth_date
+    assert_equal(1,e.year)
+    assert_equal(1,e.month)
+    assert((e.day-22).abs <= 1, "e - 22 = #{e.day - 22}")
+  end
+end
+
+describe "An Earthly date" do
+  e1 = DateTime.new(1961,5,31)
+  it "should (approximately) make the conversion roundtrip" do
+    m1 = MarsDateTime.new(e1)
+    e2 = m1.earth_date
+    diff = e2 - e1
+    assert(diff.abs <= 0.01, "Difference = #{diff}")
+  end
+end
+
+describe "A Martian date" do
+  m1 = MarsDateTime.new(1067,1,1)
+  it "should (approximately) make the conversion roundtrip" do
+    e1 = m1.earth_date
+    m2 = MarsDateTime.new(e1)
+    diff = m2 - m1
+    assert(diff.abs < 0.01)
+  end
+end
+
+describe "An arbitrary Martian date" do
+  m1 = MarsDateTime.new(1069,15,24)
+  m2 = MarsDateTime.new(933,6,4)
+  m3 = MarsDateTime.new(1055,14,1)
+  it "should format well with strftime" do
+    assert_equal("Mon",m1.strftime("%a"))
+    assert_equal("Monday",m1.strftime("%A"))
+    assert_equal("Aug",m1.strftime("%b"))
+    assert_equal("M-August",m1.strftime("%B"))
+    assert_equal("24",m1.strftime("%d"))
+    assert_equal("24",m1.strftime("%e"))
+    assert_equal("1069-15-24",m1.strftime("%F"))
+    assert_equal("416",m1.strftime("%j"))
+    assert_equal("15",m1.strftime("%m"))
+    assert_equal("0",m1.strftime("%s"))
+    assert_equal("2",m1.strftime("%u"))
+    assert_equal("60",m1.strftime("%U"))
+    assert_equal("1",m1.strftime("%w"))
+    assert_equal("1069/15/24",m1.strftime("%x"))
+    assert_equal("1069",m1.strftime("%Y"))
+    assert_equal("\n",m1.strftime("%n"))
+    assert_equal("\t",m1.strftime("%t"))
+    assert_equal("%",m1.strftime("%%"))
+
+    assert_equal("Wed",m2.strftime("%a"))
+    assert_equal("Wednesday",m2.strftime("%A"))
+    assert_equal("Leo",m2.strftime("%b"))
+    assert_equal("Leo",m2.strftime("%B"))
+    assert_equal("04",m2.strftime("%d"))
+    assert_equal(" 4",m2.strftime("%e"))
+    assert_equal("933-06-04",m2.strftime("%F"))
+    assert_equal("144",m2.strftime("%j"))
+    assert_equal("06",m2.strftime("%m"))
+    assert_equal("0",m2.strftime("%s"))
+    assert_equal("4",m2.strftime("%u"))
+    assert_equal("21",m2.strftime("%U"))
+    assert_equal("3",m2.strftime("%w"))
+    assert_equal("933/06/04",m2.strftime("%x"))
+    assert_equal("933",m2.strftime("%Y"))
+
+    assert_equal("Sag",m3.strftime("%b"))
+    assert_equal("Sagittarius",m3.strftime("%B"))
+  end
+end
+
+describe "An Earthly date with h:m:s" do
+  e1 = DateTime.new(1976,7,4,16,30,0)  # July 4, 1976  16:30
+  m1 = MarsDateTime.new(e1)
+  it "should make the conversion roundtrip" do
+    30.times do
+      m1 = MarsDateTime.new(e1)
+      e2 = m1.earth_date
+      diff = e2 - e1
+      assert(diff.abs <= 0.01) { STDERR.puts "    diff = #{diff}" }
+      e1 += 1
+    end
+  end
+end
+
+ describe "Martian dates" do
+   m1 = MarsDateTime.new(1068,14,22)
+   m2 = MarsDateTime.new(1068,14,21)
+   e1 = DateTime.new(2002,4,19)
+   e2 = DateTime.new(2012,9,29)
+   it "should compare with each other" do
+     assert(m1 > m2)
+     assert(m2 < m1)
+   end
+   it "should compare with Earth dates" do
+     assert(m1 > e1)
+     assert(m2 < e2)
+   end
+   it "should honor equality (within roundoff)" do
+     assert(m1 == m1)
+     assert(m1 != m2)
+   end
+ end
+
+describe "The 'now' and 'today' class methods" do
+  t1 = MarsDateTime.now
+  t0 = MarsDateTime.today
+  it "should be less than a day apart" do
+    diff = t1 - t0
+    assert(diff < 1.0)
+  end
+end
+
+describe "In M-year 1043, each month" do
+  md = (1..24).to_a.map {|mm| MarsDateTime.new(1043,mm,1) }
+  it "should start on a Thursday" do
+    md.each {|m| assert(m.day_of_week == "Thursday") }
+  end
+end
+
+describe "Converting 1961/5/31 to Martian" do
+  e = DateTime.new(1961,5,31) 
+  m = MarsDateTime.new(e)
+  it "should yield Friday M-April 9, 1043 MCE" do
+    assert(m.year == 1043, "bad year: #{m.year}")
+    assert(m.month == 7, "bad month: #{m.month}")
+    assert(m.sol == 9, "bad sol: #{m.sol}")
+  end
+  it "should give a Martian Saturday" do
+    assert(m.day_of_week == "Friday", "got: #{m.day_of_week}")
+  end
+end
+
+describe "The 1609 Martian equinox" do
+  e = DateTime.new(1609,3,12).new_offset(-5)
+  m = MarsDateTime.new(e)
+  m11 = MarsDateTime.new(856,1,1)
+  it "should fall on or near 1/1 (MCE)" do
+    diff = (m11-m).abs
+    assert(diff < 1.0, "Difference = #{diff}")
+  end
+end
+
+describe "The 1902 Martian equinox" do
+  e = DateTime.new(1902,8,12,7,0,0).new_offset(-5)
+  m = MarsDateTime.new(e)
+  m11 = MarsDateTime.new(1012,1,1)
+  it "should fall on or near 1/1 (MCE)" do
+    diff = (m11-m).abs
+    assert(diff < 1.0, "Difference: #{diff}")
+  end
+end
+
+describe "A Martian date" do
+  puts "***** Entering problem test..."
+  m = MarsDateTime.new(1068,1,1)
+  p m
+  describe "plus 7 days" do
+    m2 = m + 7
+    p m2
+    it "should be the same day of the week" do
+      assert_equal(m.day_of_week, m2.day_of_week)
+    end
+  end
+  describe "plus 14 days" do
+    m3 = m + 14
+    p m3
+    it "should be the same day of the week" do
+      assert_equal(m.day_of_week, m3.day_of_week)
+    end
+  end
+  describe "plus 21 days" do
+    m4 = m + 21
+    p m4
+    it "should be the same day of the week" do
+      assert_equal(m.day_of_week, m4.day_of_week)
+    end
+  end
+  puts "***** Exiting problem test"
+end
+
+describe "Martian April 1, 1043" do
+  m = MarsDateTime.new(1043,7,1)
+  it "should be a Thursday" do
+    assert_equal(m.day_of_week,"Thursday")
+  end
+end
+ 
+describe "A Martian date" do
+  md = MarsDateTime.new(1062,20,20)
+  m2 = MarsDateTime.new(1062,20,17) 
+  it "should allow subtraction of another date" do
+    m = md - m2
+    assert( (m - 3.0) < 0.01)   # sols
+  end
+  it "should allow subtraction of an Earth date" do
+    e = DateTime.new(1998, 3, 12, 16, 45, 0)
+    m = md - e
+    assert( (m - 3.0) < 0.01)   # sols
+  end
+  it "should allow subtraction of a Fixnum" do
+    m = md - 3                 # sols
+    assert( (m - m2) < 0.01)
+  end
+  it "should allow subtraction of a Float" do
+    m = md - 3.0               # sols
+    assert( (m - m2) < 0.01)
+  end
+end
+
+