time_array 0.5.1 → 0.5.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad5a748553784421e97b4911badf2b763d310f51
-  data.tar.gz: 2d48f7f257bcb85d1f2bd46aaa6eb48a2dbbb572
+  metadata.gz: d5965e94e2612aaf9f33334ec98289aea593c762
+  data.tar.gz: 679f503a720a0fb2e5bce7d8246e4de9e8476539
 SHA512:
-  metadata.gz: ca3b5ea83272254b1797bb1b7214e0a306ed433ba41a81c700a39f4c922ea69b361c38d0699d61cb16ef42a3c5d0a90ad3361cfaf3165b800798d3bc0ddbddc5
-  data.tar.gz: fd69fb50dbd4309ad9d3c825368e4d35e103ea7d82c78ace777b4e2188528266d9498d59fc04707898413d3f0cc75f36273bcea4f84cef9c4e77652529fe1e0e
+  metadata.gz: 3944a04e10b519709ebaae2d6c216c06a51e3b41a08879e93409d201414ff97c0bb395cf163c3fe6ad6528e54f2ff6e8b2f6027c7fd5694e4e8e6314ba83855a
+  data.tar.gz: aaf432f844f63690dae1e57d66084d42363f0525114500532d0f5bc67c158f26c317f028bba6721d61e0eed0d60ccf8882bbaacb3722da4e901875b9878a7bc7

data/lib/time_array/compactor.rb

@@ -0,0 +1,79 @@
+module TimeArray
+
+
+  class CompactorTime
+    attr_reader :time
+    def initialize(t)
+      @time = t
+      # @time = Time.new(t.year, t.month, t.day, t.hour, 0, 0)
+    end
+    
+    def change(step=:hour)
+      nxt = @time+1.send(step)
+      [:year, :month, :day, :hour].each do |st|
+        return st if nxt.send(st)!=@time.send(st)
+      end
+    end
+
+    def increment(step=:hour)
+      @time+1.send(step)
+    end
+    
+    def increment!(step=:hour)
+      @time = increment(step)
+    end
+  end
+
+
+  class GreatestUnit
+    H = {eternity: 5, year: 4, month: 3, day: 2, hour: 1}
+    attr_reader :c
+
+    def initialize(initial_interval=:eternity)
+      @c = initial_interval
+    end
+
+    def set(interval)
+      @c = interval if H[interval]<H[@c]
+    end
+    
+    def smallest
+      H.keys.last
+    end
+  end
+
+
+  class Compact
+    attr_reader :v, :unit
+    def initialize(v, unit)
+      @v    = v
+      @unit = unit
+    end
+    alias :values :v
+    alias :array :v
+    
+  end
+
+  class Unit
+    ETERNITY = 4
+    YEAR     = 3
+    MONTH    = 2
+    DAY      = 1
+    HOUR     = 0
+    
+    def self.name(num)
+      case num
+      when ETERNITY
+        :eternity
+      when YEAR
+        :year
+      when MONTH
+        :month
+      when DAY
+        :day
+      else
+        :hour
+      end
+    end
+  end
+end

data/lib/time_array/exceptions.rb

@@ -6,4 +6,9 @@ module TimeArray
   class NilVectorError < RuntimeError
     
   end
+
+
+  class DateTimeOutRangeError < RuntimeError
+    
+  end
 end

data/lib/time_array/time_array.rb

@@ -8,8 +8,20 @@ module TimeArray
   class TimeArray
     attr_reader :start_time, :v, :unit
 
+    # Used by each method
+    class TimeAndValue
+      attr_reader :time, :value
+      def initialize(time, value)
+        @time  = time
+        @value = value
+      end
+
+      alias_method :datetime, :time
+      alias_method :v, :value
+    end
+
     def initialize(start_time, values=Vector.new, options={})
-      manage_options(options)
+      manage_options options
       set_start_time start_time
       set_values     values      
     end
@@ -27,10 +39,9 @@ module TimeArray
       TimeArray.new(@start_time, (@v.clone rescue Vector.new), zone: Time.zone.name)
     end
 
-    # Set all vector values to a new value
+    # Set array values to the given new value
     def all_to(new_value)
       @v = Vector.new(@v.size, new_value)
-      # @v.map!{|e| e=new_value}
       self
     end
 
@@ -199,6 +210,153 @@ module TimeArray
       h
     end
 
+
+    # Will return a Compact object, a compacted version of values
+    # compact.gu gives the greatest_unit, compact.v gives the values array
+    def compact
+      gu = greatest_unit
+      puts "gu: #{gu.inspect}"
+      return Compact.new(@v, gu) if gu==:hour
+      i, st, v = 0, @start_time, []
+      while i<@v.size
+        v << @v[i]
+        next_st = st+1.send(gu)
+        h = (next_st-st)/3600
+        i = i+h.to_i
+        st = next_st
+      end
+      Compact.new(v, gu)
+    end
+
+
+    # Find the greatest unit time.
+    # If the values are contant along the month, the
+    # greatest unit is :month
+    def greatest_unit
+      v = @v.first
+      unit = Unit::YEAR # Unit::ETERNITY
+      each_with_time do |el|
+
+        # el.time
+        # el.value
+        if v!=el.value
+          if el.time.year_changed? and unit>Unit::YEAR
+            unit = Unit::YEAR
+          else
+            if el.time.month_changed? and unit>Unit::MONTH
+              unit = Unit::MONTH
+            else
+              if el.time.day_changed? and unit>Unit::DAY
+                unit = Unit::DAY
+              else
+                unit = Unit::HOUR
+                break
+              end
+            end
+          end
+        end
+        v = el.value
+      end
+      return Unit.name(unit)
+    end
+
+
+
+    def if_zero_then(other_array)
+      return self if other_array.nil?
+      raise NilVectorError if @v.nil? || (other_array.is_a?(TimeArray) && other_array.v.nil?)
+
+      c = self.clone
+      if other_array.is_a? Numeric
+        default_value = other_array
+      else
+        c.align_with(other_array)
+      end
+      
+      c.size.times do |i|
+        c.set_value(i, default_value || other_array.value(i) || 0.0) if c.value(i).zero?
+      end
+      c
+    end
+    alias_method :if_zero, :if_zero_then
+
+
+    def month_sum
+      h = {}
+      @v.each_with_index do |value, i|
+        time = @start_time + i.hours
+        h[time.month] ||= 0.0
+        h[time.month] += value
+      end
+      c = self.clone 
+      c.size.times do |i|
+        time = @start_time + i.hours
+        c.set_value(i, h[time.month])
+      end
+      c
+    end
+
+    # get the count of month hours
+    def month_count
+      h = {}
+      @v.size.times do |i|
+        time = @start_time + i.hours
+        h[time.month] ||= 0.0
+        h[time.month] += 1
+      end
+
+      # @v.each_with_index do |value, i|
+      #   time = @start_time + i.hours
+      #   h[time.month] ||= 0.0
+      #   h[time.month] += 1
+      # end
+      
+      c = self.clone 
+      c.size.times do |i|
+        time = @start_time + i.hours
+        c.set_value(i, h[time.month])
+      end
+      c
+    end
+
+    # execute the block (likely a calculation) on each vector element.
+    # and return a new time_array obj
+    def execute(&block)
+      v = @v.map &block
+      TimeArray.new(@start_time, v, zone: Time.zone.name)
+    end
+
+    # Iterates each hour, the elements are the values of array
+    # time_array.each do |value|
+    #   value
+    # end
+    def each(&block)
+      @v.each &block
+    end
+
+
+    # Get value associated to a date
+    def value_at(datetime_or_year, month=nil, day=nil, hour=nil)
+      if datetime_or_year.is_a? Time
+        dt = datetime_or_year
+      else
+        dt = Time.zone.parse("#{datetime_or_year}-#{month}-#{day} #{hour}:00")
+      end
+      i = ((dt - @start_time)/3600.0).to_i
+      raise DateTimeOutRangeError if i<0 || i>(size-1)
+      value(i)
+    end
+
+
+    # Iterates each hour, the elements are TimeAndValue objects
+    # time_array.each_with_time do |el|
+    #   e.time
+    #   e.value
+    # end
+    def each_with_time(&block)
+      arr = @v.map.with_index{|v, i| TimeAndValue.new(@start_time+i.hours, v)}
+      arr.each(&block)
+    end
     # ===========================================================
 
     private
@@ -244,6 +402,7 @@ module TimeArray
       vector
     end
 
+
     def set_start_time(start_time)
       st = read_start_time(start_time)
       @start_time = floor_start_time(st, @unit)

data/lib/time_array/time_ext.rb

@@ -0,0 +1,27 @@
+require 'active_support/core_ext/time/zones'
+
+module TimeArray
+  module TimeExt
+    
+    module InstanceMethods
+      # has year changed in last hour?
+      def year_changed?
+        self.year != (self-1.hour).year
+      end
+
+      # has year changed in last month?
+      def month_changed?
+        self.month != (self-1.hour).month
+      end
+
+      # has year changed in last day?
+      def day_changed?
+        self.day != (self-1.hour).day
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/time_array/version.rb

@@ -1,3 +1,3 @@
 module TimeArray
-  VERSION = "0.5.1"
+  VERSION = "0.5.7.4"
 end

data/lib/time_array.rb

@@ -7,6 +7,8 @@
   array_ext
   units
   group_hash
+  compactor
+  time_ext
 ).each { |file| require File.join(File.dirname(__FILE__), 'time_array', file) }
 
 
@@ -14,3 +16,6 @@ class Array
   include TimeArray::ArrayExt
 end
 
+class Time
+  include TimeArray::TimeExt
+end

data/spec/time_array_compact_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'active_support/core_ext/time/zones'
+
+RSpec.describe 'compactor' do
+  subject(:year) { "2013" }
+  subject(:y_arr) { [3.14] }
+  subject(:m_arr) { (1..12).to_a.map{|e| e%2==0 ? 1.2 : 2.98} }
+  subject(:d_arr) { (1..365).to_a.map{|e| e%2==0 ? 1.2 : 2.98} }
+  subject(:h_arr) { (1..8760).to_a.map{|e| e%2==0 ? 1.2 : 2.98} }
+
+  def build_flat_array(year, step)
+    Time.zone = "Rome"
+    t0 = Time.zone.parse("#{year}-01-01")
+    t1 = t0+1.year
+    size = (t1-t0)/3600
+    Array.new(size){|i| (t0+i.hours).send(step) }
+  end
+
+  context 'initial unit is hour' do
+    it "compact month to hour" do
+      arr = build_flat_array(2013, :month)
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:month)
+
+      arr[2] = -1.0    # dirty, degrade to :hour
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:hour)
+    end
+
+    it "compact day to hour" do
+      arr = build_flat_array(2013, :day)
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:day)
+
+      arr[2] = -1.0 # dirty, degrade to :hour
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:hour)
+    end
+
+    it "cannot compact" do
+      ta = TimeArray::TimeArray.new(year, h_arr)
+      expect(ta.greatest_unit).to eq(:hour)
+    end
+
+    it "compact an array shorten than year" do
+      arr = Array.new(24, 1.4)
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:day)
+
+      arr = Array.new(24*31, 1.4)
+      ta = TimeArray::TimeArray.new(year, arr)
+      expect(ta.greatest_unit).to eq(:month)
+    end
+  end
+
+  context 'initial unit is not hour' do
+
+    it "compact to year" do
+      ta = TimeArray::TimeArray.new(year, y_arr, unit: :year)
+      expect(ta.greatest_unit).to eq(:year)
+
+      arr = Array.new(8760, 4.1)
+      ta = TimeArray::TimeArray.new(year, arr)
+    end
+
+    it "compact to month" do
+      ta = TimeArray::TimeArray.new(year, m_arr, unit: :month)
+      st = ta.start_time.clone
+      expect(ta.greatest_unit).to eq(:month)
+      expect(ta.start_time).to eq(st)
+    end
+
+    it "compact to day" do
+      ta = TimeArray::TimeArray.new(year, d_arr, unit: :day)
+      expect(ta.greatest_unit).to eq(:day)
+    end
+  end
+
+
+  context 'compact method' do
+    it "compact to year" do
+      ta = TimeArray::TimeArray.new(year, y_arr, unit: :year)
+      compact = ta.compact
+      expect(compact.unit).to eq(:year)
+      expect(compact).to respond_to(:v)
+      expect(compact).to respond_to(:values)
+      expect(compact).to respond_to(:array)
+      expect(compact.v).to eq(y_arr)
+    end
+
+    it "compact to month" do
+      ta = TimeArray::TimeArray.new(year, m_arr, unit: :month)
+      compact = ta.compact
+      expect(compact.unit).to eq(:month)
+      expect(compact.v).to eq(m_arr)
+    end
+
+    it "compact to day" do
+      ta = TimeArray::TimeArray.new(year, d_arr, unit: :day)
+      compact = ta.compact
+      expect(compact.unit).to eq(:day)
+      expect(compact.v).to eq(d_arr)
+    end
+
+    it "compact to hour" do
+      ta = TimeArray::TimeArray.new(year, h_arr, unit: :hour)
+      compact = ta.compact
+      expect(compact.unit).to eq(:hour)
+      expect(compact.v).to eq(h_arr)
+    end
+  end
+end

data/spec/time_array_counts_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe 'hour array counts' do
+  # subject(:v1) { Array.new([0,1,-2,5,-7,11,-13]) }
+  # subject(:v2) { Array.new([1,7,19,31,-13,5,-2]) }
+  v1 = [0,1,-2,5,-7,11,-13]
+  v2 = [1,7,19,31,-13,5,-2]
+  v12 = v1.map.with_index{|e,i| v1[i]+v2[i]}
+  ta1 = TimeArray::TimeArray.new("2013", v1)
+  ta2 = TimeArray::TimeArray.new("2013", v2)
+  ta12 = TimeArray::TimeArray.new("2013", v12)
+
+  it 'sum all elements' do
+    # expect((ta1.sum(ta2)).v).to eq(ta12.v)
+    # expect(ta1.v).to eq(v1)
+  end
+end

data/spec/time_array_operations_spec.rb

@@ -50,4 +50,98 @@ RSpec.describe 'operations' do
     expect(c.size).to eq(8760)
     expect(c.sum).to eq(Float::INFINITY)
   end
+
+  it "sum month values" do
+    year = 2013
+    b = TimeArray::TimeArray.new(year.to_s, [1], unit: :year)
+    b = b.month_sum
+    h = {}
+    Time.zone = "Rome"
+    12.times do |m|
+      t1 = Time.zone.parse("#{year}-#{m+1}-01 00:00")
+      t2 = t1+1.month
+      t3 = (t2-t1)/3600
+      hours = t3.to_i
+      h[m+1] = hours
+    end
+    h.each_pair do |month, count|
+      expect(b.value_at(year,month,1,0)).to eq(count)
+    end
+  end
+
+  describe "#value_at" do
+    context 'date as datetime' do
+      context 'correct date' do
+        it "return the correct first value" do
+          Time.zone = "Rome"
+          dt = Time.zone.parse("2013-01-01 00:00")
+          expect(a1.value_at(dt)).to eq(2.1)
+        end
+        it "return the correct last value" do
+          Time.zone = "Rome"
+          dt = Time.zone.parse("2013-12-31 23:00")
+          expect(a1.value_at(dt)).to eq(2.1)
+        end
+        it "return the correct inner value" do
+          Time.zone = "Rome"
+          dt = Time.zone.parse("2013-05-21 05:00")
+          expect(a1.value_at(dt)).to eq(2.1)
+        end
+      end
+      context 'date not correct' do
+        it "raise error with a date before" do
+          Time.zone = "Rome"
+          dt = Time.zone.parse("2012-12-31 23:00")
+          expect{ a1.value_at(dt)}.to raise_error(RuntimeError)
+        end
+        it "raise error with a date after" do
+          Time.zone = "Rome"
+          dt = Time.zone.parse("2014-01-01 00:00")
+          expect{ a1.value_at(dt)}.to raise_error(RuntimeError)
+        end
+      end
+      
+    end
+
+    context 'date as numbers' do
+      context 'correct date' do
+        it "return the correct first value" do
+          expect(a1.value_at(2013,1,1,0)).to eq(2.1)
+        end
+        it "return the correct last value" do
+          expect(a1.value_at(2013,12,31,23)).to eq(2.1)
+        end
+        it "return the correct inner value" do
+          expect(a1.value_at(2013,5,21,5)).to eq(2.1)
+        end
+      end
+      context 'date not correct' do
+        it "raise error with a date before" do
+          expect{ a1.value_at(2012,12,31,23)}.to raise_error(RuntimeError)
+        end
+        it "raise error with a date after" do
+          expect{ a1.value_at(2014,1,1,0)}.to raise_error(RuntimeError)
+        end
+      end
+
+    end
+
+    it "#month_count" do
+      a = a1.month_count
+      expect(a.value(0)).to eq(24*31)
+      expect(a.value(1)).to eq(24*31)
+      expect(a.value(24*31)).to eq(24*28)
+      expect(a.value(24*31+24*28)).to eq(24*31-1) # because of daylight saving time
+      expect(a.value(a.size-1)).to eq(24*31)
+    end
+
+    it '#execute' do
+      b = a1.execute do |v|
+        2 * v + 1
+      end
+      expect(b.value(0)).to eq(2*2.1+1)
+      expect(b.value(1000)).to eq(2*2.1+1)
+      expect(b.value(b.size-1)).to eq(2*2.1+1)
+    end
+  end
 end

data/spec/time_array_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe 'time array' do
+describe TimeArray do
   subject(:a1) { TimeArray::TimeArray.new("2013", [1,2,3], zone: "Rome", unit: :hour) }
   values = [1,2,3]
   subject(:v1) { [0,1,2,-3,0,2,-1] }
@@ -209,4 +209,58 @@ RSpec.describe 'time array' do
     a = TimeArray::TimeArray.new("2013", arr, zone: "Rome", unit: :hour)
     expect(a.first_values(23)).to eq(arr[0...23])
   end
+
+
+  describe "#if_zero_then" do
+    it "compare to another timearray" do
+      a = TimeArray::TimeArray.new("2013", [1,2,0,4,5,0,7,0,0], zone: "Rome", unit: :hour)
+      b = TimeArray::TimeArray.new("2013", [9,0,7,6,5,4,3,0,1], zone: "Rome", unit: :hour)
+
+      expect(a.if_zero_then(b).v).to eq([1,2,7,4,5,4,7,0,1])
+      expect(b.if_zero_then(a).v).to eq([9,2,7,6,5,4,3,0,1])
+    end
+
+    it "compare to a number" do
+      a = TimeArray::TimeArray.new("2013", [1,2,0,4,5,0,7,0,0], zone: "Rome", unit: :hour)
+      expect(a.if_zero_then(10).v).to eq([1,2,10,4,5,10,7,10,10])
+    end
+
+  end
+
+  describe "#each" do
+    it "get values" do
+      a = TimeArray::TimeArray.new("2013", [1,2,3,4], zone: "Rome", unit: :hour)
+      a.each.with_index do |el, i|
+        expect(el).to eq(i+1)
+      end
+    end
+  end
+
+  describe "#each_with_time" do
+    it "get values" do
+      a = TimeArray::TimeArray.new("2013", [1,2,3,4], zone: "Rome", unit: :hour)
+      a.each_with_time.with_index do |el, i|
+        expect(el.value).to eq(i+1)
+        expect(el.v).to eq(i+1) # alias
+      end
+    end
+
+    it "get datetimes" do
+      a = TimeArray::TimeArray.new("2013", [1,2,3,4], zone: "Rome", unit: :hour)
+      
+      a.each_with_time.with_index do |el, i|
+        expect(el.datetime).to eq(a.start_time+i.hours)
+        expect(el.time).to eq(a.start_time+i.hours) # alias
+      end
+    end
+  end
+
+  it "get other if zero" do
+    a = TimeArray::TimeArray.new("2013", [1,2,0,4,5,0,7,0,0], zone: "Rome", unit: :hour)
+    b = TimeArray::TimeArray.new("2013", [9,0,7,6,5,4,3,0,1], zone: "Rome", unit: :hour)
+
+    c = a.if_zero(b)
+    expect(a.if_zero(b).v).to eq([1,2,7,4,5,4,7,0,1])
+    expect(b.if_zero(a).v).to eq([9,2,7,6,5,4,3,0,1])
+  end
 end

data/spec/time_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe 'time' do
+  subject(:a1) { [1,2,3].timed("2014") }
+
+  describe 'year_changed?' do
+    it "is true" do
+      expect(Time.new(2015,1,1,0,20).year_changed?).to be true
+    end
+
+    it "is false" do
+      expect(Time.new(2015,1,1,1,0).year_changed?).to be false
+      expect(Time.new(2015,1,2,0,20).year_changed?).to be false
+      expect(Time.new(2015,2,1,0,20).year_changed?).to be false
+    end
+  end
+
+  describe 'month_changed?' do
+    it "is true" do
+      expect(Time.new(2015,1,1,0,20).month_changed?).to be true
+      expect(Time.new(2015,2,1,0,20).month_changed?).to be true
+    end
+
+    it "is false" do
+      expect(Time.new(2015,1,1,1,0).month_changed?).to be false
+      expect(Time.new(2015,1,2,0,20).month_changed?).to be false
+    end
+  end
+
+  describe 'day_changed?' do
+    it "is true" do
+      expect(Time.new(2015,1,1,0,20).day_changed?).to be true
+      expect(Time.new(2015,1,2,0,20).day_changed?).to be true
+      expect(Time.new(2015,2,1,0,20).day_changed?).to be true
+    end
+
+    it "is false" do
+      expect(Time.new(2015,1,1,1,0).day_changed?).to be false
+    end
+  end
+end

data/usage/usage_01.rb

@@ -1,20 +1,46 @@
 require_relative '../lib/time_array'
 
+if false
+  arr = TimeArray::TimeArray.new("2016-03", [1,2,3])
+  puts arr.start_time.to_s
+  puts arr.start_time.class
+  puts arr.start_time.inspect
 
-arr = TimeArray::TimeArray.new("2016-03", [1,2,3])
-puts arr.start_time.to_s
-puts arr.start_time.class
-puts arr.start_time.inspect
+  # puts Time.zone.parse("2014")
+  # puts Time.zone.parse("2020-01-02")
 
-# puts Time.zone.parse("2014")
-# puts Time.zone.parse("2020-01-02")
+  a = [2,3,4].timed("2012", unit: :day)
+  puts a.size
+  puts a.v.inspect
 
-a = [2,3,4].timed("2012", unit: :day)
-puts a.size
-puts a.v.inspect
 
+  puts [1,2,3].timed("2014", unit: :day).size
 
-puts [1,2,3].timed("2014", unit: :day).size
+  puts arr.group_by(:day)
+  puts arr.group_by(:hour)
+
+
+  puts arr.start_time.strftime("%Y-%m-%d %H:%M")
+
+end
+
+if true
+  ta = TimeArray::TimeArray.new("2015", [1,2,2,2,2,2,2,2,2,2,2,2], unit: :month)
+  # puts ta.v.inspect
+  ta2 = ta.compact
+  puts ta2.v.inspect
+  puts ta2.inspect # TimeArray::Compact
+
+end
+
+if true
+  interval = :month
+  start_time = Time.new(2015,1,1)
+  array = [1,2,2,2,2,2,2,2,2,2,2,2]
+  ta1 = array.timed(start_time, unit: interval)
+  # puts ta1
+  ta2 = ta1.compact
+  puts ta2.inspect
+  puts ta2
+end
 
-puts arr.group_by(:day)
-puts arr.group_by(:hour)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: time_array
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.7.4
 platform: ruby
 authors:
 - Iwan Buetti
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-06 00:00:00.000000000 Z
+date: 2016-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -181,18 +181,23 @@ files:
 - Rakefile
 - lib/time_array.rb
 - lib/time_array/array_ext.rb
+- lib/time_array/compactor.rb
 - lib/time_array/exceptions.rb
 - lib/time_array/group_hash.rb
 - lib/time_array/hour_array.rb
 - lib/time_array/time_array.rb
+- lib/time_array/time_ext.rb
 - lib/time_array/units.rb
 - lib/time_array/vector.rb
 - lib/time_array/version.rb
 - spec/array_spec.rb
 - spec/hour_array_spec.rb
 - spec/spec_helper.rb
+- spec/time_array_compact_spec.rb
+- spec/time_array_counts_spec.rb
 - spec/time_array_operations_spec.rb
 - spec/time_array_spec.rb
+- spec/time_spec.rb
 - spec/units_spec.rb
 - spec/vector_spec.rb
 - time_array.gemspec
@@ -217,7 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Some tools to deal with time based arrays
@@ -225,8 +230,10 @@ test_files:
 - spec/array_spec.rb
 - spec/hour_array_spec.rb
 - spec/spec_helper.rb
+- spec/time_array_compact_spec.rb
+- spec/time_array_counts_spec.rb
 - spec/time_array_operations_spec.rb
 - spec/time_array_spec.rb
+- spec/time_spec.rb
 - spec/units_spec.rb
 - spec/vector_spec.rb
-has_rdoc: