carray-timeindex 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 153dcf26b31edb8e20d73fb215d9e162ce99ae236358ade3d3960aa3948d5787
+  data.tar.gz: 82ff276b24790f304e3cdf23ec2e0ec6cbc6a865af4f12c66e59e7bc1097bb79
+SHA512:
+  metadata.gz: 234f5551eef62046111adb11a414ea40a4dfb5e2a0dc95c8960178e7d5e7b736e81a5b0bc1128367abdd54b2b170b921586be8daec7fffcf6e0b8c9864181112
+  data.tar.gz: 79f4ee563e9fec51a5de2687f75abb68faec0b3d79857b228dd44924ddc0388da37e125ed2b573af59350f10333b85e406fbc5368d039a1faeac883b665e6133

data/README.md

@@ -0,0 +1,2 @@
+carray-timeindex
+================

data/Rakefile

@@ -0,0 +1,11 @@
+GEMSPEC = "carray-timeindex.gemspec"
+
+task :install do
+  spec = eval File.read(GEMSPEC)
+  system %{
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+  }
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/carray-timeindex.gemspec

@@ -0,0 +1,23 @@
+
+Gem::Specification::new do |s|
+  version = "0.9.0"
+
+  files = Dir.glob("**/*") - [ 
+                               Dir.glob("carray-timeindex*.gem"), 
+                             ].flatten
+
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "carray-timeindex"
+  s.summary     = "TimeIndex in Ruby"
+  s.description = <<-HERE
+    TimeIndex in Ruby
+  HERE
+  s.version     = version
+  s.author      = "Hiroki Motoyoshi"
+  s.email       = ""
+  s.homepage    = 'https://github.com/himotoyoshi/carray-timeindex'
+  s.files       = files
+  s.required_ruby_version = ">= 2.4.1"
+  s.add_runtime_dependency 'carray', '~> 1.3', '>= 1.3.8'
+end
+

data/lib/carray-timeindex.rb

@@ -0,0 +1,2 @@
+require "timesteps"
+require "carray-timeindex/core"

data/lib/carray-timeindex/core.rb

@@ -0,0 +1,737 @@
+require "carray"
+require "timesteps"
+require "stringio"
+
+autoload :CADataFrame, "carray-dataframe"
+
+class TimeStep
+
+  def to_ca (n = 1)
+    return CATimeIndex.new(self, count: n)
+  end
+  
+end
+
+class TimeStep::Range
+
+  def to_ca 
+    return CATimeIndex.new(@timestep, count: @count)
+  end
+  
+end
+
+class CATimeIndex < CArray
+
+  def self.concat (*args)
+    reference = args.shift
+    ts_ref = reference.timestep
+    array = [reference]
+    args.each_with_index do |series, i|
+      array << series.new_timestep(ts_ref)
+    end
+    return CATimeIndex.new(ts_ref) { CArray.bind(:int64, array, 0) }
+  end
+
+  def self.datetime_new (year=0, month=1, day=1, hour=0, minute=0, second=0.0, offset: 0, unit: nil)
+    params = [year, month, day, hour, minute, second]
+    size   = params.map {|x| x.is_a?(Numeric) ? 1 : x.size }.max
+    ref = CArray.object(size)
+    arrays = params.map {|x| x.is_a?(Numeric) ? ref.template{ x } : x.to_ca }
+    CArray.join(arrays).to_a.each_with_index do |(*args), i|
+      ref[i] = DateTime.new(*args, offset)
+    end
+    return CATimeIndex.from_time_array(ref, unit || "sec", since: ref[0])
+  end
+
+  def self.range (since, last = nil, format: nil, offset: nil, calendar: "standard", count: nil, unit: nil, freq: "days", ends: "[]")
+    raise "'ends' option should be one of '[]', '()', '(]', '[)" unless ends =~ /\A[\[\(][\]\)]\z/
+    if freq.is_a?(Numeric)
+      numeric, symbol = TimeStep.split_interval_spec(unit)
+      freq = format("%g %s", freq, symbol)
+    end
+    freqstep = TimeStep.new(freq, since: since, format: format, calendar: calendar, offset: offset)
+    timestep = if unit
+                 TimeStep.new(unit, since: since, format: format, calendar: calendar, offset: offset)
+               else
+                 freqstep
+               end               
+    pair  = freqstep.to(timestep)
+    index = freqstep.range(since, last, count: count, ends: ends).map_index{|k| pair.forward(k) }
+    CATimeIndex.from_index_array(index, timestep, calendar: calendar, offset: offset)
+  end
+
+  def self.from_time_array (array, spec, since: nil, format: nil, offset: nil, calendar: "standard")
+    timestep = case spec
+               when TimeStep
+                 spec
+               when String
+                 TimeStep.new(spec, since: since, format: format, calendar: calendar, offset: offset)
+               else
+                 raise "'spec' argument should be a String or a TimeStep"
+               end
+    array = array.to_ca unless array.kind_of?(CArray)
+    index = array.convert(:int64) {|t| timestep.index_at(t).floor }
+    return self.new(timestep) { index }
+  end
+
+  def self.from_index_array (array, spec, since: nil, format: nil, calendar: "standard", offset: nil)
+    since = array.timestep.origin if array.is_a?(CATimeIndex) && since.nil?
+    timestep = case spec
+               when TimeStep
+                 spec
+               when String
+                 TimeStep.new(spec, since: since, format: format, calendar: calendar, offset: offset)
+               else
+                 raise "'spec' argument should be a String or a TimeStep"
+               end
+    array = array.to_ca unless array.kind_of?(CArray)
+    return self.new(timestep) { array }
+  end
+
+  def initialize (spec, since: nil, calendar: "standard", offset: nil, count: nil, freq: nil, &block)
+
+    @timestep = case spec
+                when TimeStep
+                  spec
+                when String
+                  TimeStep.new(spec, calendar: calendar, offset: offset)
+                else
+                  raise "'spec' should be a TimeStep or String object"
+                end
+
+    @timestep = @timestep.new_origin(since) if since
+
+    if block
+      # initialize with block return value
+      index = block.call
+      index = index.to_ca unless index.kind_of?(CArray)
+      index = index.int64 unless index.data_type != CA_INT64
+      super(:int64, [index.size]) 
+      self[] = index
+    else
+      raise "count should be given unless block is given" unless count
+      raise "count argument should be an integer" unless count.is_a?(Integer)
+      super(:int64, [count])
+      if freq
+        target = case freq
+                 when TimeStep
+                   freq
+                 when String
+                   TimeStep.new(freq, calendar: @timestep.calendar, offset: @timestep.offset)
+                 else
+                   raise "argument shoud be an TimeStep or String or CATimeIndex"
+                 end
+        target = target.new_origin(@timestep.origin)
+        self[] = CATimeIndex.new(target, count: count).time.
+                                   convert(:int64) {|t| timestep.index_at(t).floor } 
+      else
+        self.seq!
+      end
+    end
+
+  end
+
+  attr_reader :timestep
+
+  def new_timestep (spec, since: nil, &block)
+    since = @timestep.origin unless since
+    target = case spec
+             when TimeStep
+               spec
+             when String
+               TimeStep.new(spec, since: since)
+             when CATimeIndex
+               spec.timestep
+             else
+               raise "argument shoud be an TimeStep or String or CATimeIndex"
+             end
+    pair = @timestep.to(target)
+    obj = CATimeIndex.new(target) { convert {|i| pair.forward(i).floor } }
+    obj = block.call(obj).new_timestep(@timestep) if block
+    return obj
+  end
+
+  alias in new_timestep
+
+  def shift_origin (index, with: "index")
+    timestep = @timestep.shift_origin(index, with: with)
+    return new_timestep(timestep)
+  end
+
+  def new_origin (origin)
+    timestep = @timestep.new_origin(origin)
+    return new_timestep(timestep)
+  end
+
+  def new_offset (offset)
+    origin = @timestep.origin.new_offset(offset)
+    return new_timestep(@timestep.new_origin(origin))
+  end
+
+  def time (*args)
+    index = self[*args]
+    return @timestep.time_at(index) if index.is_a?(Numeric)
+    return index.convert(:object) {|i| @timestep.time_at(i) }
+  end
+
+  REGEXP_DATETIME = /\A
+                    ([+\-]?\d{1,4})
+                    (?:\-(\d{1,2}))?
+                    (?:\-(\d{1,2}))?
+                    (?:\s+
+                      (\d{1,2})
+                      (?::(\d{1,2}))?
+                      (?::(\d{1,2}))?
+                    )?
+                    \z/x
+
+  def expand_to_period (spec)
+    if spec =~ REGEXP_DATETIME
+      interval = "year"
+      interval = "month"  if $2
+      interval = "day"    if $3
+      interval = "hour"   if $4
+      interval = "minute" if $5
+      interval = "second" if $6
+    else
+      return nil
+    end
+    origin = @timestep.parse(spec)
+    return TimePeriod.new(unit, since: origin, calendar: @timestep.calendar)
+  end
+
+  private :expand_to_period
+
+  def match (spec)
+    case spec
+    when Range
+      idx1 = spec.begin
+      idx1 = expand_to_period(idx1).start if idx1.is_a?(String)
+      idx2 = spec.end
+      idx2 = expand_to_period(idx2).last if idx2.is_a?(String)
+      return (self >= idx1).and(self <= idx2)
+    when String
+      period = expand_to_period(spec)
+      return (self >= period.start).and(self <= period.last)
+    else
+      raise "argument should be a Range or String"
+    end
+  end
+
+  def to_ca
+    return CATimeIndex.new(@timestep) { super } 
+  end
+
+  def spec_to_timestep (spec)
+    case spec
+    when TimeStep
+      return spec
+    when String
+      case spec
+      when /since/
+        return TimeStep.new(spec, offset: @timestep.offset, calendar: @timestep.calendar)
+      else
+        return TimeStep.new(spec, since: @timestep.parse("0000-01-01"), offset: @timestep.offset, calendar: @timestep.calendar)
+      end
+    else
+      raise "'spec' argument '#{spec}' can't be convert to timestep"
+    end
+  end
+  
+  private :spec_to_timestep
+
+  def round_to_array (array, direction: nil)
+    raise "'array' should be CATimeIndex" unless array.is_a?(CATimeIndex)
+    target = array.in(@timestep)
+    index  = target.double.section(self)
+    case direction
+    when :up, "up"
+      time = target.time.project(index.ceil)
+      return CATimeIndex.from_time_array(time, @timestep)
+    when :down, "down"
+      time = target.time.project(index.floor)
+      return CATimeIndex.from_time_array(time, @timestep)
+    end
+  end
+
+  private :round_to_array
+
+  def round (*args, direction: nil, to: nil)
+    case args.size
+    when 1
+      num = 1
+      spec = args[0]
+    when 2
+      num = args[0]
+      spec = args[1]
+    else
+      raise "invalid number of argumets"
+    end
+
+    if spec.is_a?(CATimeIndex)
+      if num == 1
+        return round_to_array(spec, direction: direction)
+      else
+        raise "invalid numeric for array"
+      end
+    end
+
+    timestep = spec_to_timestep(spec)
+    
+    pair = @timestep.to(timestep)
+
+    case to
+    when nil
+      case direction
+      when :up, "up"
+        index = convert{ |i| pair.inverse( pair.forward(i).ceil + num - 1 ) }
+      when :down, "down"
+        index = convert{ |i| pair.inverse( pair.forward(i).floor ) }
+      else
+        index = convert{ |i| pair.inverse( pair.forward(i).round ) }
+      end
+    when :end, "end"
+      case direction
+      when :up, "up"
+        index = convert{ |i| pair.inverse( pair.forward(i).floor + num ) - 1 }
+      when :down, "down"
+        index = convert{ |i| pair.inverse( pair.forward(i).floor ) - 1 }
+      else
+        raise "can't round with 'to' option"
+      end
+    when :start, "start"
+      case direction
+      when :up, "up"
+        index = convert{ |i| pair.inverse( pair.forward(i).floor + num )  }
+      when :down, "down"
+        index = convert{ |i| pair.inverse( pair.forward(i).floor ) }
+      else
+        raise "can't round with 'to' option"
+      end
+    else
+      raise "unknown 'to' option '#{to}'"
+    end
+    
+    return CATimeIndex.from_index_array(index, @timestep)
+  end
+
+  private :round
+
+  def floor (*args, to: nil)
+    return round(*args, direction: :down, to: to)
+  end
+
+  def ceil (*args, to: nil)
+    return round(*args, direction: :up, to: to)
+  end
+  
+  def next (*args)
+    case args.size
+    when 1
+      num = 1
+      spec = args[0]
+    when 2
+      num = args[0]
+      spec = args[1]
+    else
+      raise "invalid number of argumets"
+    end
+    return self.in(spec) {|t| t + num }
+  end
+
+  def prev (*args)
+    case args.size
+    when 1
+      num = 1
+      spec = args[0]
+    when 2
+      num = args[0]
+      spec = args[1]
+    else
+      raise "invalid number of argumets"
+    end
+    return self.in(spec) {|i| i - num }
+  end
+
+  def [] (*argv)
+    obj = super
+    obj = CATimeIndex.from_index_array(obj, @timestep) if obj.kind_of?(CArray)
+    return obj
+  end
+
+  def ajd
+    return convert(:float64) {|i| @timestep.time_at(i).ajd }
+  end
+
+  def jd
+    return convert(:int64) {|i| @timestep.time_at(i).jd }
+  end
+
+  def year
+    unit = TimeStep.new("years", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:int64) {|i| pair.forward(i) }
+  end
+
+  def month
+    unit = TimeStep.new("months", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:int32) {|i| pair.forward(i) % 12 + 1 }
+  end
+
+  def day
+    return convert(:int32) {|i| @timestep.time_at(i).day }
+  end
+
+  def wday
+    return convert(:int32) {|i| @timestep.time_at(i).wday }
+  end
+
+  def is_sunday
+    return convert(:boolean) {|i| @timestep.time_at(i).sunday? }
+  end
+
+  def is_monday
+    return convert(:boolean) {|i| @timestep.time_at(i).monday? }
+  end
+
+  def is_tuesday
+    return convert(:boolean) {|i| @timestep.time_at(i).tuesday? }
+  end
+
+  def is_wednesday
+    return convert(:boolean) {|i| @timestep.time_at(i).wednesday? }
+  end
+
+  def is_thursday
+    return convert(:boolean) {|i| @timestep.time_at(i).thursday? }
+  end
+
+  def is_friday
+    return convert(:boolean) {|i| @timestep.time_at(i).friday? }
+  end
+
+  def is_saturday
+    return convert(:boolean) {|i| @timestep.time_at(i).saturday? }
+  end
+  
+  def hour
+    unit = TimeStep.new("hours", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:int32) {|i| pair.forward(i) % 24 }
+  end
+
+  def minute
+    unit = TimeStep.new("minutes", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:int32) {|i| pair.forward(i) % 60 }
+  end
+
+  def second
+    unit = TimeStep.new("seconds", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:int32) {|i| pair.forward(i).floor % 60 }
+  end
+
+  def second_fraction
+    unit = TimeStep.new("seconds", since: @timestep.parse("0000-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return convert(:float64) {|i| s = pair.forward(i); s - s.floor }
+  end
+
+  def next_year (n = 1)
+    index = convert {|i| @timestep.index_at( @timestep.time_at(i).next_year(n) ) }
+    return CATimeIndex.new(@timestep) { index }
+  end
+
+  def prev_year (n = 1)
+    return next_year(-n)
+  end
+
+  def next_month (n = 1)
+    index = convert {|i| @timestep.index_at( @timestep.time_at(i).next_month(n) ) }
+    return CATimeIndex.new(@timestep) { index }
+  end
+
+  def prev_month (n = 1)
+    return next_month(-n)
+  end
+
+  def next_day (n = 1)
+    index = convert {|i| @timestep.index_at( @timestep.time_at(i).next_day(n) ) }
+    return CATimeIndex.new(@timestep) { index }
+  end
+
+  def prev_day (n = 1)
+    return next_day(-n)
+  end
+
+  def next_hour (n = 1)
+    unit = TimeStep.new("hours", since: @timestep.parse("1970-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return CATimeIndex.new(@timestep) { convert {|i| pair.inverse(pair.forward(i) + n) } }
+  end
+
+  def prev_hour (n = 1)
+    return next_hour(-n)
+  end
+
+  def next_minute (n = 1)
+    unit = TimeStep.new("minutes", since: @timestep.parse("1970-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return CATimeIndex.new(@timestep) { convert {|i| pair.inverse(pair.forward(i) + n) } }
+  end
+
+  def prev_minute (n = 1)
+    return next_minute(-n)
+  end
+
+  def next_second (n = 1)
+    unit = TimeStep.new("seconds", since: @timestep.parse("1970-01-01"), calendar: @timestep.calendar)
+    pair = @timestep.to(unit)
+    return CATimeIndex.new(@timestep) { convert {|i| pair.inverse(pair.forward(i) + n) } }
+  end
+
+  def prev_second (n = 1)
+    return next_second(-n)
+  end
+
+  def offset
+    value = @timestep.offset
+    if value.denominator == 1
+      return template(:int) { value }
+    else
+      return template(:object) { value }
+    end
+  end
+
+  def < (other)
+    case other
+    when String
+      if period = expand_to_period(other)
+        self < period.first
+      else
+        self < @timestep.parse(other)
+      end
+    when DateTime, DateTimeLike
+      return self < @timestep.index_at(other)
+    when CATimeIndex
+      return super(other.new_timestep(@timestep))
+    else
+      super
+    end
+  end
+  
+  alias lt <
+
+  def <= (other)
+    case other
+    when String
+      if period = expand_to_period(other)
+        return self <= period.last
+      else
+        return self <= @timestep.parse(other)
+      end
+    when DateTime, DateTimeLike
+      return self <= @timestep.index_at(other)
+    when CATimeIndex
+      return super(other.new_timestep(@timestep))
+    else
+      super
+    end
+  end
+  
+  alias le <=
+
+  def > (other)
+    case other
+    when String
+      if period = expand_to_period(other)
+        return self > period.last
+      else
+        return self > @timestep.parse(other)
+      end
+    when DateTime, DateTimeLike
+      return self > @timestep.index_at(other)
+    when CATimeIndex
+      return super(other.new_timestep(@timestep))
+    else
+      super
+    end
+  end
+  
+  alias gt >
+
+  def >= (other)
+    case other
+    when String
+      if period = expand_to_period(other)
+        return self >= period.start
+      else
+        return self >= @timestep.parse(other)
+      end
+    when DateTime, DateTimeLike
+      return self >= @timestep.index_at(other)
+    when CATimeIndex
+      return super(other.new_timestep(@timestep))
+    else
+      super
+    end
+  end
+  
+  alias ge >=
+
+  def eq (other)
+    case other
+    when String
+      return eq(@timestep.parse(other))
+    when DateTime, DateTimeLike
+      return eq(@timestep.index_at(other))
+    when CATimeIndex
+      return super(other.new_timestep(@timestep))
+    else
+      super
+    end
+  end
+
+  def + (other)
+    case other
+    when String
+      numeric, spec = TimeStep.split_interval_spec(other)
+      if numeric < 0
+        return self - "#{-numeric.to_i} #{spec}"
+      end
+      case spec
+      when /\-end\z/
+        case numeric
+        when 0
+          return self
+        else
+          spec = spec.sub(/\-end\z/, '')
+          return (self + "#{(numeric.to_i-1)} #{spec}").ceil(spec, to: :end)        
+        end
+      when /\-start\z/
+        case numeric
+        when 0
+          return self
+        else
+          spec = spec.sub(/\-start\z/, '')
+          return (self + "#{(numeric.to_i-1)} #{spec}").floor(spec, to: :start)        
+        end
+      when /\Ayears?\z/
+        next_year(numeric)
+      when /\Amonths?\z/
+        next_month(numeric)
+      when /\Aweeks?\z/
+        next_day(7*numeric)
+      when /\Adays?\z/
+        next_day(numeric)
+      when /\Ahours?\z/
+        next_hour(numeric)
+      when /\Aminutes?\z/
+        next_minute(numeric)
+      when /\Aseconds?\z/
+        next_seconds(numeric)
+      else
+        return self.next(numeric, spec)
+      end
+    else
+      return CATimeIndex.new(@timestep) { add(other) }
+    end
+  end
+
+  def - (other)
+    case other
+    when DateTime, DateTimeLike
+      return sub(@timestep.index_at(other))
+    when CATimeIndex
+      return sub(other.new_timestep(@timestep))
+    when String
+      numeric, spec = TimeStep.split_interval_spec(other)
+      if numeric < 0
+        return self + "#{-numeric.to_i} #{spec}"
+      end
+      case spec
+      when /\-end\z/
+        case numeric
+        when 0
+          return self
+        else
+          spec = spec.sub(/\-end\z/, '')
+          return (self - "#{numeric.to_i} #{spec}").ceil(spec, to: :end)        
+        end
+      when /\-start\z/
+        case numeric
+        when 0
+          return self
+        else
+          spec = spec.sub(/\-start\z/, '')
+          return (self - "#{numeric.to_i} #{spec}").floor(spec, to: :start)        
+        end
+      when /\Ayears?\z/
+        prev_year(numeric)
+      when /\Amonths?\z/
+        prev_month(numeric)
+      when /\Aweeks?\z/
+        prev_day(7*numeric)
+      when /\Adays?\z/
+        prev_day(numeric)
+      when /\Ahours?\z/
+        prev_hour(numeric)
+      when /\Aminutes?\z/
+        prev_minute(numeric)
+      when /\Aseconds?\z/
+        prev_seconds(numeric)
+      else
+        return self.prev(numeric, spec)
+      end
+    else
+      return CATimeIndex.new(@timestep) { sub(other) }
+    end
+  end
+  
+  def strftime (format)
+    return time.str_strftime(format)
+  end
+  
+  def concat (*others)
+    return CATimeIndex.concat(self, *others)
+  end
+  
+  def inspect
+    io = StringIO.new
+    io.puts "CATimeIndex: rows#=#{elements()}"
+    io.puts "timestep = " + @timestep.definition
+    body = CADataFrame.new({element: self.int64, "time value": time})
+#    body = CArray.join([(0...self.size).to_ca,self.int64,self.time])
+    io.puts body.inspect.each_line.to_a[1..-1]
+    return io.string.chomp
+  end
+
+  def to_html
+    io = StringIO.new
+    io.puts "CATimeIndex: rows#=#{elements()}<br>"
+    io.puts "timestep = " + @timestep.definition + "<br>"
+    body = CADataFrame.new({element: self.int64, "time value": time})
+    io.puts body.to_html.each_line.to_a[1..-1]
+    return io.string.chomp
+  end
+
+  ["shift"].each do |method_name|
+    class_eval %{
+      def #{method_name} (*args)
+        return CATimeIndex.from_index_array(super, @timestep)         
+      end
+    }
+  end
+
+  def marshal_dump()
+    return [self.int64, @timestep]
+  end
+  
+  def marshal_load (data)
+    index, timestep = *data
+    initialize(timestep) { index}
+  end
+
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: carray-timeindex
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Hiroki Motoyoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: carray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.8
+description: "    TimeIndex in Ruby\n"
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- carray-timeindex.gemspec
+- lib/carray-timeindex.rb
+- lib/carray-timeindex/core.rb
+homepage: https://github.com/himotoyoshi/carray-timeindex
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: TimeIndex in Ruby
+test_files: []