timesteps 0.9.3

data/lib/timesteps/timestepconverter.rb

@@ -0,0 +1,63 @@
+require "timesteps"
+
+class TimeStep::Converter
+  
+  def initialize (reference, calendar: "standard", bc: false)
+    @calendar = calendar
+    @bc = bc
+    case reference
+    when String
+      @reference = TimeStep.new(reference, calendar: calendar, bc: bc)
+    when TimeStep
+      @reference = reference
+    else
+      raise "first argument should be TimeStep or string"
+    end
+    @pair = {}
+    @target = {}
+    self["reference"] = reference
+  end
+  
+  # Append or reset new target time step for the given name.
+  #
+  def []= (name, spec)
+    @pair[name] = TimeStep::Pair.new(@reference, spec, calendar: @calendar, bc: @bc)
+    @target[name] = @pair[name].to
+    return @target[name]
+  end
+
+  # Return target time step of the given name.
+  #
+  def [] (name)
+    return @target[name]
+  end
+  
+  # Relete target of the given name.
+  #
+  def delete (name)
+    @pair.delete(name)
+    @target.delete(name)
+  end
+
+  def forward (*indices)
+    hash = {}
+    @pair.each do |name, conv|
+      hash[name] = conv.forward(*indices)
+    end
+    return hash
+  end
+
+  def valid? (*indices)
+    hash = {}
+    @pair.each do |name, conv|
+      hash[name] = conv.to.valid?(*conv.forward(*indices))
+    end
+    return hash
+  end
+
+  def time_at (index)
+    return @from.time_at(index)
+  end
+
+end
+

data/lib/timesteps/timestepdatetimeext.rb

@@ -0,0 +1,79 @@
+
+class TimeStep
+
+  module DateTimeExt
+  
+    refine DateTime do
+    
+      # Returns time fraction in day units.
+      #
+      # @return [Rational]
+      def fraction ()
+        return (60*(60*hour + minute) + second + second_fraction).quo(86400)
+      end
+
+      def compare_md (other)
+        sday = self.day + self.fraction + self.offset
+        oday = other.day + other.fraction + other.offset
+        if self.month > other.month
+          return 1
+        elsif self.month < other.month
+          return -1
+        else
+          if sday > oday
+            return 1
+          elsif sday < oday
+            return -1
+          else
+            return 0
+          end
+        end
+      end
+
+      def compare_d (other)
+        sday = self.day + self.fraction + self.offset
+        oday = other.day + other.fraction + other.offset
+        if sday > oday
+          return 1
+        elsif sday < oday
+          return -1
+        else
+          return 0
+        end
+      end
+
+      # Calculate difference between the object and other object in years.
+      #
+      # @return [Integer]
+      def difference_in_years (other)
+        extra = 0
+        if self.year > other.year && self.compare_md(other) < 0
+          extra = -1
+        end
+        if self.year < other.year && self.compare_md(other) > 0
+          extra = 1
+        end
+        return self.year - other.year + extra
+      end
+      
+      # Calculate difference between the object and other object in months.
+      #
+      # @return [Integer]
+      def difference_in_months (other)
+        extra = 0
+        if self.month > other.month && self.compare_d(other) < 0
+          extra = -1
+        end
+        if self.month < other.month && self.compare_d(other) > 0
+          extra = 1
+        end
+        return 12*(self.year - other.year) + self.month - other.month + extra  
+      end
+      
+    end
+
+  end
+
+end
+
+

data/lib/timesteps/timesteppair.rb

@@ -0,0 +1,202 @@
+
+class TimeStep::Pair
+
+  using TimeStep::DateTimeExt
+
+  # Constructs the object.
+  #
+  # The `from` and `to` arguments are either TimeStep or a string representing
+  # the time step definition ("<INTERVAL> since <TIME>").
+  # If a string representing the time step definition is given as an argument
+  # `from` or `to`, the options `calendar` and `bc` are used to construct
+  # TimeStep. The option `calendar` specifies the calendar for datetime
+  # calculation. The option `bc` is a flag whether AD/BC or EC when parsing
+  # timestamp for negative year.
+  #
+  # @param from [TimeStep, String]
+  # @param to [TimeStep, String]
+  # @option calendar [String, TimeStep::Calendar]
+  # @option bc [Boolean]
+  # 
+
+  def initialize (from, to, calendar: "standard", bc: false)
+
+    case from
+    when String
+      @from = TimeStep.new(from, calendar: calendar, bc: bc)
+    when TimeStep
+      @from = from
+    else
+      raise "first argument should be TimeStep or string"
+    end
+            
+    case to
+    when String
+      @to = TimeStep.new(to, calendar: calendar, bc: bc)
+    when TimeStep
+      @to = to
+    else
+      raise "second argument should be TimeStep or string"
+    end
+
+    @from_origin = @from.origin
+    @to_origin   = @to.origin
+        
+    @from_interval = @from.interval
+    @to_interval   = @to.interval
+
+    @from_symbol   = @from.symbol
+    @to_symbol     = @to.symbol
+
+    if @from_symbol == :years or @from_symbol == :months or
+       @to_symbol == :years or @to_symbol == :months
+      @numeric_conversion = false      
+    else
+      @numeric_conversion = true
+    end
+
+    @difference = ( (@from_origin.jd + @from_origin.fraction - @from_origin.offset) - 
+                    (@to_origin.jd   + @to_origin.fraction - @to_origin.offset) ) * 86400
+  end
+  
+  attr_reader :from, :to, :difference
+    
+  def inspect
+    "#<TimeStep::Pair from='#{from.inspect}' to='#{to.inspect}'>"
+  end
+  
+  # Returns true if other has same contents of `from` and `to` as self has.
+  #
+  # @return [Boolean]
+  def == (other)
+    return @from == other.from && 
+           @to == other.to 
+  end
+  
+  def time_at (*indices)
+    @from.time_at(*indices)
+  end
+  
+  def forward (*indices, &block)
+    if indices.size == 1    
+      index = indices.first.to_r
+      if @numeric_conversion
+        value = (index*@from_interval + @difference).quo(@to_interval)
+      else
+        case @from_symbol
+        when :years, :months
+          target = @from.time_at(index)
+        else
+          target = @from_origin + index*(@from_interval.quo(86400))
+        end
+        case @to_symbol
+        when :years        
+          value = target.difference_in_years(@to_origin).quo(@to.numeric)
+        when :months
+          value = target.difference_in_months(@to_origin).quo(@to.numeric)
+        else
+          value = (target.ajd - @to_origin.ajd).quo(@to_interval)
+        end
+      end
+      value = value.to_i if value.denominator == 1
+      if block
+        return block[value]
+      else
+        return value
+      end
+    else
+      if block
+        return indices.map { |index| block[forward(index)] }
+      else
+        return indices.map { |index| forward(index) }
+      end
+    end
+  end
+
+  alias [] forward
+
+  def forward_time (index)
+    if @numeric_conversion
+      return @to.time_at((index*@from_interval + @difference).quo(@to_interval))
+    else
+      case @from_symbol
+      when :years, :months
+        target = @from.time_at(index)
+      else
+        target = @from_origin + index*(@from_interval.quo(86400))
+      end
+      case @to_symbol
+      when :years
+        index = (target.year - @from_origin.year).quo(@to.numeric)
+      when :months
+        ms = 12*(target.year - @from_origin.year)
+        ms += target.month - @from_origin.month
+        index = ms.quo(@to.numeric)
+      else
+        index = (target.ajd - @from_origin.ajd).quo(@to_interval)
+      end
+      return @to.time_at(index)
+    end      
+  end
+
+  def inverse (*indices, &block)
+    if indices.size == 1    
+      index = indices.first.to_r
+      if @numeric_conversion
+        value = (index*@to_interval - @difference).quo(@from_interval)
+      else
+        case @to_symbol
+        when :years, :months
+          target = @to.time_at(index)
+        else
+          target = @to_origin + index*(@to_interval.quo(86400))
+        end
+        case @from_symbol
+        when :years        
+          value = target.difference_in_years(@from_origin).quo(@from.numeric)
+        when :months
+          value = target.difference_in_months(@from_origin).quo(@from.numeric)
+        else
+          value = (target.ajd - @from_origin.ajd).quo(@from_interval)
+        end
+        if block
+          return block[value]
+        else
+          return value
+        end
+      end
+    else
+      if block
+        return indices.map { |index| block[inverse(index)] }
+      else
+        return indices.map { |index| inverse(index) }
+      end
+    end
+  end
+
+  # 
+  def inverse_time (index)
+    if @numeric_conversion
+      return @from.time_at((index*@to_interval - @difference).quo(@from_interval))
+    else
+      case @to_symbol
+      when :years, :months
+        target = @to.time_at(index)
+      else
+        target = @to_origin + index*(@to_interval.quo(86400))
+      end
+      case @from_symbol
+      when :years
+        index = (target.year - @to_origin.year).quo(@from.numeric)
+      when :months
+        ms = 12*(target.year - @to_origin.year)
+        ms += target.month - @to_origin.month
+        index = ms.quo(@from.numeric)
+      else
+        index = (target.ajd - @to_origin.ajd).quo(@from_interval)
+      end
+      return @from.time_at(index)
+    end
+  end
+    
+end

data/lib/timesteps.rb

@@ -0,0 +1,10 @@
+
+require "date"
+require "timesteps/datetimelike"
+require "timesteps/parse_timestamp"
+require "timesteps/format"
+require "timesteps/timestepdatetimeext"
+require "timesteps/calendar"
+require "timesteps/timestep"
+require "timesteps/timesteppair"
+require "timesteps/timestepconverter"

data/spec/allleap_spec.rb

@@ -0,0 +1,330 @@
+# rspec-power_assert
+require 'timesteps'
+require 'rspec-power_assert'
+
+describe "AllLeap.new" do
+
+  example 'full arguments' do
+
+    is_asserted_by { 
+      DateTime::AllLeap.new(-4712,1,1,0,0,0,0).is_a?(DateTime::AllLeap) 
+    }
+
+    d = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+
+    is_asserted_by { d.year   == 2001 }
+    is_asserted_by { d.month  == 3    }
+    is_asserted_by { d.day    == 5    }
+    is_asserted_by { d.hour   == 9    }
+    is_asserted_by { d.minute == 35   }
+    is_asserted_by { d.second + d.second_fraction == 12.5 }
+    is_asserted_by { d.offset == 9.quo(24) }
+
+  end  
+
+  example 'ommitted arguments' do
+
+    is_asserted_by { 
+      DateTime::AllLeap.new().is_a?(DateTime::AllLeap) 
+    }
+
+    d = DateTime::AllLeap.new()
+
+    is_asserted_by { d.year   == -4712 }
+    is_asserted_by { d.month  == 1     }
+    is_asserted_by { d.day    == 1     }
+    is_asserted_by { d.hour   == 0     }
+    is_asserted_by { d.minute == 0     }
+    is_asserted_by { d.second + d.second_fraction == 0.0   }
+    is_asserted_by { d.offset == 0     }
+
+  end  
+
+  example "raised for invalid date" do
+
+    # leap day for allleap calendar
+    is_asserted_by { 
+      DateTime::AllLeap.new(2020,2,29).is_a?(DateTime::AllLeap) 
+    }
+
+    # date not exist
+    expect { DateTime::AllLeap.new(2020,4,31) }.to raise_error(RuntimeError)
+
+  end
+
+end
+
+describe "AllLeap.jd" do
+
+  example "epoch" do
+
+    d = DateTime::AllLeap.jd(0)    
+    is_asserted_by { d.jd == 0 }
+
+  end
+
+  example "unixpoch" do
+
+    jd = DateTime::AllLeap::UNIX_EPOCH_IN_AJD.ceil
+
+    d = DateTime::AllLeap.jd(jd)    
+    is_asserted_by { d.jd == jd }
+    is_asserted_by { d.year  == 1970 }
+    is_asserted_by { d.month == 1 }
+    is_asserted_by { d.day   == 1 }
+
+  end
+
+end
+
+describe "AllLeap#<=>" do
+
+  example {
+
+    d1 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    d2 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+
+    is_asserted_by { d1 == d2 }
+    
+  }
+      
+end
+
+describe "AllLeap.parse_timestamp" do
+
+  example '2001-03-05T09:35:12.5+09:00' do
+
+    d1 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+
+    [
+      '2001-03-05T09:35:12.5+09:00',
+      '2001-03-05 09:35:12.5 +09:00',
+      '2001-03-05 09:35:12.5 +0900',
+      '2001-03-05 09:35:12.5 +900',
+      '2001-03-05 09:35:12.5 +09',
+      '2001-03-05 09:35:12.5 +9',
+      '2001/03/05 09:35:12.5 +09:00',
+      '2001-3-5 9:35:12.5 +09:00',
+      '05,Mar,2001 09:35:12.5 +09:00',
+      '05-Mar-2001 09:35:12.5 +09:00',
+    ].each do |string|
+      
+      d2 = DateTime::AllLeap.parse_timestamp(string)
+
+      is_asserted_by { d2 == d1 }
+    end
+
+  end  
+
+  example 'raise for "2000-02-29"' do
+
+    # leap day for noleap calendar
+    is_asserted_by { DateTime::AllLeap.parse_timestamp("2000-2-29").is_a?(DateTime::AllLeap) }
+    
+  end
+
+  example "with bc option" do
+    
+    d1 = DateTime::AllLeap.new(0, 1, 1, 0, 0, 0, 0)
+    d2 = DateTime::AllLeap.parse_timestamp('BC 0001-1-1 00:00:00')
+    d3 = DateTime::AllLeap.parse_timestamp('-0001-1-1 00:00:00', bc: true)
+    
+    is_asserted_by { d2 == d1 }
+    is_asserted_by { d3 == d1 }
+    
+  end
+
+  example '2000-12-31 24:00:00' do
+
+    d1 = DateTime::AllLeap.new(2001, 1, 1, 0, 0, 0, 0)
+    d2 = DateTime::AllLeap.parse_timestamp('2000-12-31 24:00:00')
+
+    is_asserted_by { d2 == d1 }
+
+  end
+
+end
+
+describe "AllLeap#jd" do
+
+  example 'epoch' do
+
+    d = DateTime::AllLeap.new()    
+    is_asserted_by { d.jd == 0 }
+
+  end
+
+  example 'few-years' do
+
+    d = DateTime::AllLeap.new(-4712,12,31)    
+    is_asserted_by { d.jd == 365 }
+
+    d = DateTime::AllLeap.new(-4711,1,1)    
+    is_asserted_by { d.jd == 366 }
+
+    d = DateTime::AllLeap.new(-4708,1,1)    
+    is_asserted_by { d.jd == 366*4 }
+
+    d = DateTime::AllLeap.new(-4713,1,1)    
+    is_asserted_by { d.jd == -366 }
+
+    d = DateTime::AllLeap.new(-4716,1,1)    
+    is_asserted_by { d.jd == -366*4 }
+
+  end
+
+end
+
+describe "AllLeap#ajd" do
+
+  example 'epoch' do
+
+    d = DateTime::AllLeap.new()    
+    is_asserted_by { d.ajd == -1.quo(2) }
+
+  end
+
+  example 'few-years' do
+
+    d = DateTime::AllLeap.new(-4712,12,31)    
+    is_asserted_by { d.ajd == 365-1.quo(2) }
+
+    d = DateTime::AllLeap.new(-4711,1,1)    
+    is_asserted_by { d.ajd == 366-1.quo(2) }
+
+    d = DateTime::AllLeap.new(-4708,1,1)    
+    is_asserted_by { d.ajd == 366*4-1.quo(2) }
+
+    d = DateTime::AllLeap.new(-4713,1,1)    
+    is_asserted_by { d.ajd == -366-1.quo(2) }
+
+    d = DateTime::AllLeap.new(-4716,1,1)    
+    is_asserted_by { d.ajd == -366*4-1.quo(2) }
+
+  end
+
+end
+
+describe "AllLeap#strftime" do
+
+  example 'standard' do
+
+    d = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+
+    is_asserted_by { d.strftime("%FT%T.%L%:z")  == "2001-03-05T09:35:12.500+09:00" }
+    is_asserted_by { d.strftime("%Y%m%d%H%M%S") == "20010305093512" }
+
+  end
+
+end
+
+
+describe "AllLeap#next_XXX" do
+
+  example "next_year" do 
+    
+    d = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    
+    is_asserted_by { d.next_year().year   == 2002 }
+    is_asserted_by { d.next_year(10).year == 2011 }
+
+    is_asserted_by { d.prev_year().year   == 2000 }
+    is_asserted_by { d.prev_year(10).year == 1991 }
+  
+  end
+
+  example "next_month" do 
+    
+    d = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    
+    is_asserted_by { d.next_month().month   == 4 }
+    is_asserted_by { d.next_month(10).month == 1 }
+    is_asserted_by { (d>>1).month           == 4 }
+    is_asserted_by { (d>>10).month          == 1 }
+
+    is_asserted_by { d.prev_month().month   == 2 }
+    is_asserted_by { d.prev_month(10).month == 5 }
+    is_asserted_by { (d<<1).month           == 2 }
+    is_asserted_by { (d<<10).month          == 5 }
+  
+    is_asserted_by { (d>>12).year    == 2002 }
+    is_asserted_by { (d>>10*12).year == 2011 }
+    is_asserted_by { (d<<12).year    == 2000 }
+    is_asserted_by { (d<<10*12).year == 1991 }
+    
+  end
+
+  example "next_day" do 
+
+    d = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    
+    is_asserted_by { d.next_day().day   == 6 }
+    is_asserted_by { d.next_day(10).day == 15 }
+    is_asserted_by { d.next_day(31).day == 5 }
+
+    is_asserted_by { (d + 1).day  == 6 }
+    is_asserted_by { (d + 10).day == 15 }
+    is_asserted_by { (d + 31).day == 5 }
+
+    is_asserted_by { d.prev_day().day   == 4 }
+    is_asserted_by { d.prev_day(10).day == 24 }
+    is_asserted_by { d.prev_day(31).day == 3 }
+
+    is_asserted_by { (d - 1).day  == 4 }
+    is_asserted_by { (d - 10).day == 24 }
+    is_asserted_by { (d - 31).day == 3 }
+
+  end
+
+end
+
+describe "AllLeap#fraction" do
+
+  example do 
+    
+    d1 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    d2 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.893, 9.quo(24))
+    
+    is_asserted_by { d1.fraction == 9.quo(24) + 35.quo(1440) + 12.5.to_r.quo(86400) }
+    is_asserted_by { d2.fraction == 9.quo(24) + 35.quo(1440) + 12.893.to_r.quo(86400) }
+    
+  end
+
+end
+
+describe "AllLeap#difference_in_years" do
+
+  example do 
+    
+    d1 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    d2 = DateTime::AllLeap.new(2002, 3, 4, 9, 35, 12.5, 9.quo(24))
+    d3 = DateTime::AllLeap.new(2002, 3, 5, 9, 35, 11.5, 9.quo(24))
+    d4 = DateTime::AllLeap.new(2002, 3, 5, 9, 35, 12.5, 9.quo(24))
+    
+    is_asserted_by { d2.difference_in_years(d1) == 0 }
+    is_asserted_by { d3.difference_in_years(d1) == 0 }
+    is_asserted_by { d4.difference_in_years(d1) == 1 }
+    
+  end
+
+end
+
+describe "AllLeap#difference_in_months" do
+
+  example do 
+    
+    d1 = DateTime::AllLeap.new(2001, 3, 5, 9, 35, 12.5, 9.quo(24))
+    d2 = DateTime::AllLeap.new(2001, 4, 4, 9, 35, 12.5, 9.quo(24))
+    d3 = DateTime::AllLeap.new(2001, 4, 5, 9, 35, 11.5, 9.quo(24))
+    d4 = DateTime::AllLeap.new(2001, 4, 5, 9, 35, 12.5, 9.quo(24))
+    d5 = DateTime::AllLeap.new(2002, 3, 5, 9, 35, 12.5, 9.quo(24))
+    
+    is_asserted_by { d2.difference_in_months(d1) == 0 }
+    is_asserted_by { d3.difference_in_months(d1) == 0 }
+    is_asserted_by { d4.difference_in_months(d1) == 1 }
+    is_asserted_by { d5.difference_in_months(d1) == 12 }
+    
+  end
+
+end
+