timesteps 0.9.6 → 0.9.7

data/lib/timesteps/timestep_calendar.rb

@@ -1,4 +1,6 @@
 
+autoload :TZInfo, "tzinfo"
+
 class TimeStep
 
   class Calendar
@@ -23,12 +25,11 @@ class TimeStep
 
     # Construct the object
     #
-    def initialize (calendar = "standard", bc: false)
+    def initialize (calendar = "standard", tz: nil)
       unless calendar.is_a?(String)
         raise ArgumentError, "argument calendar '#{calendar}' should be string" 
       end
       @name = calendar
-      @bc   = bc
       case @name.downcase.intern
       when :standard, :gregorian
         @calendar = :standard
@@ -43,22 +44,30 @@ class TimeStep
       when SYM_360_day
         @calendar = SYM_360_day
       end
+      if tz 
+        raise "'standard' calendar needed for tz" unless @calendar == :standard
+        case tz
+        when nil
+        when String
+          @tz = TZInfo::Timezone.get(tz)
+        when TZInfo::Timezone
+          @tz = tz
+        else
+          raise "invalid tz specification"
+        end
+      end
     end
     
-    attr_reader :name, :calendar
-    
+    attr_reader :name, :calendar, :tz
+      
     def inspect 
-      "#<TimeStep::Calendar calendar='#{@calendar.to_s}' bc='#{@bc}'>"
+      "#<TimeStep::Calendar calendar='#{@calendar.to_s}'>"
     end
     
     def == (other)
-      return @calendar == other.calendar && bc? == other.bc?
-    end
-    
-    def bc?
-      return @bc ? true : false
+      return @calendar == other.calendar 
     end
-    
+        
     def valid_datetime_type? (time)
       return false unless time.is_a?(DateTimeType[@calendar])
       case @calendar
@@ -77,10 +86,31 @@ class TimeStep
     # and creates an date time instance.
     # 
     # @return [DateTime object]
-    def parse (timespec, format: nil)
-      return DateTime.parse_timestamp(timespec, calendar: @calendar.to_s, bc: @bc, format: format)
+    def parse (timespec, format: nil, offset: nil)
+      return DateTime.parse_timestamp(timespec, calendar: @calendar.to_s, format: format, tz: @tz, offset: offset)
     end
-    
+
+    def time_new (year, month, day, hour=0, min=0, sec=0, offset=0)
+      case @calendar
+      when :standard
+        time = DateTime.new(year, month, day, hour, min, sec, offset, Date::ITALY)
+      when :proleptic_gregorian
+        time = DateTime.new(year, month, day, hour, min, sec, offset, Date::GREGORIAN)
+      when :proleptic_julian
+        time = DateTime.new(year, month, day, hour, min, sec, offset, Date::JULIAN)
+      when :noleap
+        time = DateTime::NoLeap.new(year, month, day, hour, min, sec, offset)
+      when :allleap
+        time = DateTime::AllLeap.new(year, month, day, hour, min, sec, offset)
+      when SYM_360_day
+        time = DateTime::Fixed360Day.new(year, month, day, hour, min, sec, offset)
+      end
+      if @tz
+        time = @tz.to_local(time)
+      end
+      return time
+    end
+  
     def jday2date (jday)
       case @calendar
       when :standard
@@ -96,27 +126,17 @@ class TimeStep
       when SYM_360_day
         time = DateTime::Fixed360Day.jd(jday, 0, 0, 0, 0)
       end
+      if @tz
+        time = @tz.to_local(time)
+      end
       return time
     end
 
     def date2jday (year, month, day)
-      case @calendar
-      when :standard
-        time = DateTime.new(year, month, day, 0, 0, 0, 0, Date::ITALY)
-      when :proleptic_gregorian
-        time = DateTime.new(year, month, day, 0, 0, 0, 0, Date::GREGORIAN)
-      when :proleptic_julian
-        time = DateTime.new(year, month, day, 0, 0, 0, 0, Date::JULIAN)
-      when :noleap
-        time = DateTime::NoLeap.new(year, month, day, 0, 0, 0, 0)
-      when :allleap
-        time = DateTime::AllLeap.new(year, month, day, 0, 0, 0, 0)
-      when SYM_360_day
-        time = DateTime::Fixed360Day.new(year, month, day, 0, 0, 0, 0)
-      end
-      return time.jd
+      return time_new(year, month, day).jd
     end
     
   end
 
 end
+

data/lib/timesteps/timestep_converter.rb

@@ -2,12 +2,11 @@ require "timesteps"
 
 class TimeStep::Converter
   
-  def initialize (reference, name: "reference", calendar: "standard", bc: false)
+  def initialize (reference, name: "reference", calendar: "standard")
     @calendar = calendar
-    @bc = bc
     case reference
     when String
-      @reference = TimeStep.new(reference, calendar: calendar, bc: bc)
+      @reference = TimeStep.new(reference, calendar: calendar)
     when TimeStep
       @reference = reference
     else
@@ -21,9 +20,9 @@ class TimeStep::Converter
   # Append or reset new target time step for the given name.
   #
   def add_timestep (spec, name:)
-    @pair[name] = TimeStep::Pair.new(@reference, spec, calendar: @calendar, bc: @bc)
+    @pair[name] = TimeStep::Pair.new(@reference, spec, calendar: @calendar)
     @target[name] = @pair[name].to
-    return @target[name]
+    return @pair[name]
   end
   
   # Append or reset new target time step for the given name.
@@ -35,14 +34,14 @@ class TimeStep::Converter
   # Return target time step of the given name.
   #
   def [] (name)
-    return @target[name]
+    return @pair[name]
   end
   
   # Relete target of the given name.
   #
   def delete (name)
-    @pair.delete(name)
     @target.delete(name)
+    @pair.delete(name)
   end
 
   # Returns the time represented by the given index as DateTime object
@@ -56,11 +55,18 @@ class TimeStep::Converter
 
   # Converts index refering `from` timestep to index refering `to`timestep.
   #
-  def forward (*indices, with_time: false)
+  def forward (*indices, with_time: nil)
     if with_time
-      hash = {
-        "time" => time_at(*indices)        
-      }
+      case with_time
+      when String
+        hash = {
+          "time" => time_at(*indices).map{|t| t.strftime(with_time) }
+        }
+      else
+        hash = {
+          "time" => time_at(*indices)        
+        }
+      end
     else
       hash = {}
     end
@@ -70,8 +76,8 @@ class TimeStep::Converter
     return hash
   end
 
-  def range (ge: nil, gt: nil, lt: nil, le: nil, with_time: false)
-    indices = @reference.range(ge: ge, gt: gt, lt: lt, le: le)
+  def range (other, with_time: false)
+    indices = @reference.range(other)
     return forward(*indices, with_time: with_time)    
   end
 
@@ -80,14 +86,5 @@ class TimeStep::Converter
     return forward(*indices, with_time: with_time)
   end
 
-  def valid? (*indices)
-    hash = {}
-    @pair.each do |name, conv|
-      hash[name] = conv.to.valid?(*conv.forward(*indices))
-    end
-    return hash
-  end
-
-
 end
 

data/lib/timesteps/timestep_datetime_ext.rb

@@ -46,28 +46,18 @@ class TimeStep
       #
       # @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
+        my    = self
+        other = other.new_offset(self.offset)
+        return my.year - other.year + my.compare_md(other).quo(2)
       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  
+        my    = self
+        other = other.new_offset(self.offset)
+        return 12*(my.year - other.year) + my.month - other.month + my.compare_d(other).quo(2)  
       end
       
     end

data/lib/timesteps/timestep_pair.rb

@@ -8,21 +8,19 @@ class TimeStep::Pair
   # 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
+  # `from` or `to`, the options `calendar` 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.
+  # calculation. 
   #
   # @param from [TimeStep, String]
   # @param to [TimeStep, String]
   # @option calendar [String, TimeStep::Calendar]
-  # @option bc [Boolean]
   # 
-  def initialize (from, to, calendar: "standard", bc: false)
+  def initialize (from, to, calendar: "standard")
 
     case from
     when String
-      @from = TimeStep.new(from, calendar: calendar, bc: bc)
+      @from = TimeStep.new(from, calendar: calendar)
     when TimeStep
       @from = from
     else
@@ -31,7 +29,7 @@ class TimeStep::Pair
             
     case to
     when String
-      @to = TimeStep.new(to, calendar: calendar, bc: bc)
+      @to = TimeStep.new(to, calendar: calendar)
     when TimeStep
       @to = to
     else
@@ -66,13 +64,17 @@ class TimeStep::Pair
     "#<TimeStep::Pair from='#{from.inspect}' to='#{to.inspect}'>"
   end
   
+  def invert
+    return TimeStep::Pair.new(@to, @from)
+  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
-  
+    
   # Returns the time represented by the given index as DateTime object
   #
   # @param indices [Numeric,Array<Numeric>]
@@ -85,10 +87,16 @@ class TimeStep::Pair
   # Converts index refering `from` timestep to index refering `to`timestep.
   #
   def forward (*indices, &block)
-    if indices.size == 1    
+    if indices.empty? || indices.size == 1 && indices.first.is_a?(Range)
+      return forward(*@from.range(*indices), &block)
+    elsif indices.size == 1 
       index = indices.first.to_r
       if @numeric_conversion
-        value = (index*@from_interval + @difference).quo(@to_interval)
+        if @to_interval == 0
+          value = 0
+        else
+          value = (index*@from_interval + @difference).quo(@to_interval)
+        end
       else
         case @from_symbol
         when :years, :months
@@ -97,12 +105,14 @@ class TimeStep::Pair
           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 :years
+          diff = target.difference_in_years(@to_origin)
+          value = diff.quo(@to.numeric)
         when :months
-          value = target.difference_in_months(@to_origin).quo(@to.numeric)
+          diff = target.difference_in_months(@to_origin)
+          value = diff.quo(@to.numeric)
         else
-          value = (target.ajd - @to_origin.ajd).quo(@to_interval)
+          value = (target.ajd - @to_origin.ajd).quo(@to_interval)*86400
         end
       end
       value = value.to_i if value.denominator == 1
@@ -126,18 +136,19 @@ class TimeStep::Pair
     return forward(*indices) {|index| @to.time_at(index) }
   end
 
-  def range (ge: nil, gt: nil, lt: nil, le: nil)
-    indices = @from.range(ge: ge, gt: gt, lt: lt, le: le)
-    return forward(*indices)    
-  end
-
   # Converts index refering `to` timestep to index refering `from` timestep.
   #
   def inverse (*indices, &block)
-    if indices.size == 1    
+    if indices.empty? || indices.size == 1 && indices.first.is_a?(Range)
+      return inverse(*@to.range(*indices), &block)
+    elsif indices.size == 1    
       index = indices.first.to_r
       if @numeric_conversion
-        value = (index*@to_interval - @difference).quo(@from_interval)
+        if @from_interval == 0
+          value = 0
+        else
+          value = (index*@to_interval - @difference).quo(@from_interval)
+        end
       else
         case @to_symbol
         when :years, :months
@@ -147,11 +158,13 @@ class TimeStep::Pair
         end
         case @from_symbol
         when :years        
-          value = target.difference_in_years(@from_origin).quo(@from.numeric)
+          diff = target.difference_in_years(@from_origin)
+          value = diff.quo(@from.numeric)
         when :months
-          value = target.difference_in_months(@from_origin).quo(@from.numeric)
+          diff = target.difference_in_months(@from_origin)
+          value = diff.quo(@from.numeric)
         else
-          value = (target.ajd - @from_origin.ajd).quo(@from_interval)
+          value = (target.ajd - @from_origin.ajd).quo(@from_interval)*86400
         end
       end
       value = value.to_i if value.denominator == 1

data/lib/timesteps/timestep_range.rb

@@ -0,0 +1,150 @@
+require "forwardable"
+
+class TimeStep::Range 
+
+  extend Forwardable
+
+  def initialize (timestep, start = nil, last = nil, count: nil, ends: "[]")
+
+    raise "'ends' option should be one of '[]', '()', '(]', '[)" unless ends =~ /\A[\[\(][\]\)]\z/
+    include_start = ends[0] == "["
+    include_last  = ends[1] == "]"
+
+    if last
+      case start
+      when Numeric
+        raise "start and last types doesn't match" unless last.is_a?(Numeric)
+      when DateTime, DateTimeLike, String
+        if last.is_a?(Integer)
+          start = timestep.index_at(start)
+          last  = start + last - 1
+        else
+          raise "start and last types doesn't match" unless last.is_a?(start.class)
+          start  = timestep.index_at(start)
+          last   = timestep.index_at(last)
+        end
+      else
+        raise "unknown argument"
+      end
+    else
+      case start
+      when Integer
+        count = start
+        start = 0
+        last  = count - 1
+      when String
+        raise "count should be set" unless count.is_a?(Integer)
+        start = timestep.index_at(start)
+        last  = start + count - 1
+      when TimePeriod
+        period = range
+        return initialize(timestep, period.origin..period.last, ends: period.ends)
+      else
+        raise "unknown argument"
+      end
+    end
+
+    if include_start
+      @start = start.ceil
+    else
+      @start = start.floor + 1
+    end
+    
+    if include_last
+      @last = last.floor
+    else
+      @last = last.ceil - 1
+    end
+
+    @timestep = timestep.new_origin(timestep.time_at(@start))
+    @count = @last - @start + 1
+    
+    @start_time = @timestep.time_at(@start)
+    @last_time  = @timestep.time_at(@last)
+  end
+
+  attr_reader :timestep, :count, :start, :last, :start_time, :last_time
+
+  def_delegators :@timestep, :numeric, :symbol, :interval, 
+                             :origin, :offset, :calendar, :definition,
+                             :parse, :time_at, :index_at, :duration_at, :[]
+                             
+
+  # FIXME
+  def valid? (*indices)
+    if @count
+      if indices.size == 1
+        index = indices.first
+        if index >= 0 and index < @count 
+          return true
+        else
+          return false
+        end
+      else
+        return indices.map{|index| valid?(index) }
+      end
+    else
+      if indices.size == 1
+        return true
+      else
+        return indices.map{|index| true }
+      end
+    end
+  end
+
+  # Returns TimeStep object which has origin time determined 
+  # by the given `index`.
+  #
+  # @param index [Numeric]
+  #
+  # @return [TimeStep]
+  def shift_origin (index)
+    case with
+    when :index, "index"
+      timestep = @timestep.shift_origin(index)
+      return TimeStep::Range.new(timestep, count: @count)
+    when :duration, "duration", :days, "days"
+      timestep = @timestep.shift_origin(index, with: "duration")
+      return TimeStep::Range.new(timestep, count: @count)
+    end
+  end
+
+  # Returns TimeStep object which has origin time specified 
+  # by the given `time`.
+  #
+  # @param time [DateTime]
+  #
+  # @return [TimeStep]
+  def new_origin (time)
+    timestep = @timestep.new_origin(time)
+    return TimeStep::Range.new(timestep, count: @count)
+  end
+
+  include Enumerable
+  
+  def each_time (&block)
+    if block
+      @start.upto(@last) do |k|
+        block.call(@timestep.time_at(k))
+      end
+    else
+      return Enumerator.new {|y|
+        @start.upto(@last) do |k|
+          y << @timestep.time_at(k)
+        end
+      }
+    end
+  end
+
+  alias each each_time
+  
+  def each_index (&block)
+    (@start..@last).each(&block)
+  end
+
+  def map_index (&block)
+    (@start..@last).map(&block)
+  end
+
+end
+