time_series_math 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85c802a00527e11700194fcbd661d85943bcd26a
+  data.tar.gz: 4cd75e47704fbecd1557cba39cb6fa44f32e29f7
+SHA512:
+  metadata.gz: 83e1bb3b5dc55d5f83bfb8ad6abe9d7f8b14f3f2a4acdadc9717968f699d425d7b966d81b5507adf443eb080e5434d939a237195de9daaf007cad565ed808e78
+  data.tar.gz: fafb01c6289d5065f7dab7ee7a33f2f8e5e63b7cd88a0cdab343c6a1833ef1a4c8ff26f0b77ce70ce075598865d035e392898b24332b9caf41d9b9b145ab94af

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kukushkin-time_series.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alex Kukushkin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# TimeSeriesMath
+
+Time series data structures and functions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'time_series_math'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install time_series_math
+
+## Usage
+
+### TimeSeries
+
+`TimeSeries` class is a data structure for storing timestamped values.
+
+TimeSeries maintains order of its elements and provides efficient search methods
+for near-constant time access
+(depends strongly on timestamps distribution -- the more even, the better).
+
+Examples:
+
+``` ruby
+require 'time_series_math'
+
+include TimeSeriesMath
+
+# one by one element insertion:
+ts = TimeSeries.new
+ts.push 1.0, { x: 2.0, y: 3.0 }
+ts.push 1.2, { x: 2.0, y: 3.0 }
+ts.push 1.6, { x: 2.0, y: 3.0 }
+ts.push 1.9, { x: 2.0, y: 3.0 }
+ts.push 2.1, { x: 2.0, y: 3.0 }
+# .. or:
+ts[2.3] = { x: 2.5, y: 3.5 }
+ts[2.5] = { x: 2.2, y: 3.7 }
+
+# more time-efficient batch insertion using arrays:
+ts = TimeSeries.new
+tt = [ 1.0, 1.2, 1.6, 1.9, 2.1 ]
+dd = [ {x: 2.0}, {x: 2.1}, {x: 2.5}, {x: 2.7}, {x: 2.85} ]
+ts.push_array(tt, dd)
+
+# retrieve closest element before given time:
+ts[1.2] # => { x: 2.1 }
+ts[2.095] # => { x: 2.7 }
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/kukushkin/time_series_math/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rake/extensiontask'
+spec = Gem::Specification.load('time_series_math.gemspec')
+Rake::ExtensionTask.new('time_series_math_c', spec)
+
+task spec: :compile

data/examples/ts_benchmark.rb

@@ -0,0 +1,75 @@
+$LOAD_PATH.unshift '../lib'
+require 'time_series_math'
+require 'benchmark'
+
+include TimeSeriesMath
+
+def t_rand
+  rand * 1000.0
+end
+
+def b_search(ts, t)
+  return nil if t < ts.t_first
+  return ts.last if t >= ts.t_last
+  ileft = 0
+  iright = ts.size-1
+  while iright - ileft > 1
+    icenter = ileft + (iright - ileft) /2
+    if t >= ts.data[icenter][0]
+      ileft = icenter
+    else
+      iright = icenter
+    end
+  end
+  if iright - ileft != 1
+    fail "ileft:#{ileft} iright:#{iright}"
+  elsif ts.data[ileft][0] > t || ts.data[iright][0] <= t
+    puts "(ts: t_first:#{ts.t_first} t_last:#{ts.t_last}"
+    fail "t:#{t}, t_left:#{ts.data[ileft][0]}, t_right:#{ts.data[iright][0]}"
+  end
+  v = ts.data[ileft]
+end
+
+def b_search_native(ts, t)
+  v_right = ts.data.bsearch { |d| d[0] > t }
+  v_right.nil? ? ts.last : v_right[1]
+end
+
+TS_N = [1_000, 100_000, 1_000_000]
+TESTS = 1000_000
+ts_list = []
+
+TS_N.each do |num_samples|
+  puts "** initializing time series with #{num_samples} samples"
+  tt = []
+  dd = []
+  num_samples.times do
+    tt << t_rand
+    dd << { x: rand * 10.0 }
+  end
+  ts_list << TimeSeries.new(tt, dd)
+end
+
+puts '** running benchmarks'
+Benchmark.bmbm do |b|
+  ts_list.each do |ts|
+    b.report "size: #{ts.size}, running #{TESTS} times #indices_at" do
+      TESTS.times { ts.indices_at(t_rand) }
+    end
+  end
+  ts_list.each do |ts|
+    b.report "size: #{ts.size}, running #{TESTS} times #bsearch_indices_at" do
+      TESTS.times { ts.bsearch_indices_at(t_rand) }
+    end
+  end
+  ts_list.each do |ts|
+    b.report "size: #{ts.size}, running #{TESTS} times #b_search" do
+      TESTS.times { b_search(ts, t_rand) }
+    end
+  end
+  ts_list.each do |ts|
+    b.report "size: #{ts.size}, running #{TESTS} times #b_search_native" do
+      TESTS.times { b_search_native(ts, t_rand) }
+    end
+  end
+end

data/ext/time_series_math_c/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'time_series_math_c'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/time_series_math_c/time_series_math_c.c

@@ -0,0 +1,80 @@
+#include <ruby.h>
+
+// Returns timestamp at index +i+.
+//
+static double timestamp_at_i(VALUE rb_data_array, int i ) {
+    VALUE m_elem;
+
+    m_elem = rb_ary_entry(rb_data_array, i);
+    return NUM2DBL( rb_ary_entry(m_elem, 0) );
+}
+
+// Returns indices of elements surrounding timestamp +t+.
+// The pair of indices is found using binary search over sorted @data array.
+//
+// Ruby equivalent:
+//
+// def indices_at(t)
+//   return [nil, nil] if size == 0
+//   return [nil, 0] if t < t_first
+//   return [size - 1, nil] if t >= t_last
+//   ileft = 0
+//   iright = size - 1
+//   while iright - ileft > 1
+//     icenter = ileft + (iright - ileft) / 2
+//     if t >= data[icenter][0]
+//       ileft = icenter
+//     else
+//       iright = icenter
+//     end
+//   end
+//   [ileft, iright]
+// end
+//
+static VALUE time_series_bsearch_indices_at(VALUE rb_self, VALUE rb_t) {
+    VALUE m_data;
+    int _size;
+    double _t;
+    int _ileft, _iright, _icenter;
+
+    m_data = rb_iv_get(rb_self, "@data");
+    _size = RARRAY_LEN(m_data);
+    _t = NUM2DBL(rb_t);
+
+    // initial conditions check:
+    if ( _size == 0 ) {
+        return rb_ary_new3( 2, Qnil, Qnil );
+    }
+    if ( _t < timestamp_at_i( m_data, 0 ) ) {
+        return rb_ary_new3( 2, Qnil, INT2FIX(0) );
+    }
+    if ( _t >= timestamp_at_i( m_data, _size-1 ) ) {
+        return rb_ary_new3( 2, INT2FIX(_size-1), Qnil );
+    }
+
+    // find left & right indices using binary search:
+    _ileft = 0;
+    _iright = _size - 1;
+    while ( _iright - _ileft > 1 ) {
+        _icenter = _ileft + ( _iright - _ileft ) / 2;
+        if ( _t >= timestamp_at_i( m_data, _icenter) ) {
+            _ileft = _icenter;
+        } else {
+            _iright = _icenter;
+        }
+    }
+    return rb_ary_new3( 2, INT2FIX(_ileft), INT2FIX(_iright) );
+}
+
+void Init_time_series_math_c() {
+    // get TimeSeriesMath module
+    ID sym_TimeSeriesMath = rb_intern("TimeSeriesMath");
+    VALUE mTimeSeriesMath = rb_const_get(rb_cObject, sym_TimeSeriesMath);
+
+    // get TimeSeriesMath::TimeSeries class
+    ID sym_TimeSeries = rb_intern("TimeSeries");
+    VALUE kTimeSeries = rb_const_get(mTimeSeriesMath, sym_TimeSeries);
+
+    // define TimeSeriesMath::TimeSeries#bsearch_indices_at
+    rb_define_method(kTimeSeries, "bsearch_indices_at", time_series_bsearch_indices_at, 1);
+}

data/lib/time_series_math.rb

@@ -0,0 +1,11 @@
+require 'time_series_math/version'
+require 'time_series_math/time_series'
+require 'time_series_math/elemwise_operators'
+require 'time_series_math/linear_interpolation'
+
+# load C extensions
+require 'time_series_math_c'
+
+module TimeSeriesMath
+  # Your code goes here...
+end

data/lib/time_series_math/elemwise_operators.rb

@@ -0,0 +1,56 @@
+module TimeSeriesMath
+  #
+  # == ElemwiseOperators
+  # A collection of helper functions for by-element operations:
+  # * addition
+  # * substraction
+  # * multiplication by scalar
+  #
+  module ElemwiseOperators
+    #
+    # Element-wise addition of objects
+    #
+    def elemwise_add(obj1, obj2)
+      case obj1
+      when Array
+        obj1.clone.zip(obj2).map { |d| d[0] + d[1] }
+      when Hash
+        out = {}
+        obj1.each { |k, v| out[k] = v + obj2[k] }
+        out
+      else
+        obj1 + obj2
+      end
+    end
+
+    # Element-wise substraction of objects
+    #
+    def elemwise_sub(obj1, obj2)
+      case obj1
+      when Array
+        obj1.clone.zip(obj2).map { |d| d[0] - d[1] }
+      when Hash
+        out = {}
+        obj1.each { |k, v| out[k] = v - obj2[k] }
+        out
+      else
+        obj1 - obj2
+      end
+    end
+
+    # Element-wise multiplication by scalar
+    #
+    def elemwise_mul_scalar(scalar, obj)
+      case obj
+      when Array
+        obj.clone.map { |d| d * scalar }
+      when Hash
+        out = {}
+        obj.each { |k, v| out[k] = v * scalar }
+        out
+      else
+        obj * scalar
+      end
+    end
+  end # module ElemwiseOperators
+end # module TimeSeriesMath

data/lib/time_series_math/linear_interpolation.rb

@@ -0,0 +1,16 @@
+module TimeSeriesMath
+  module LinearInterpolation
+    include ElemwiseOperators
+    # Returns interpolated value.
+    #
+    def [](t)
+      i0, i1 = indices_at(t)
+      return first[1] if i0.nil?
+      return last[1] if i1.nil?
+
+      k = (t - @data[i0][0]) / (@data[i1][0] - @data[i0][0])
+      diff_value = elemwise_sub(@data[i1][1], @data[i0][1])
+      elemwise_add(@data[i0][1], elemwise_mul_scalar(k, diff_value))
+    end
+  end
+end # module TimeSeriesMath

data/lib/time_series_math/time_series.rb

@@ -0,0 +1,167 @@
+module TimeSeriesMath
+  #
+  # = TimeSeries
+  # TimeSeries class provides an efficient data structure for storing timestamped data values.
+  #
+  # TimeSeries maintains order of its elements and provides efficient search methods
+  # for near-constant time access
+  # (depends strongly on timestamps distribution -- the more even, the better).
+  #
+  # == Examples:
+  #
+  #   require 'time_series_math'
+  #   include TimeSeriesMath
+  #
+  #   # one by one element insertion
+  #   ts = TimeSeries.new
+  #   ts.push 1.0, { x: 2.0, y: 3.0 }
+  #   ts.push 1.2, { x: 2.0, y: 3.0 }
+  #   ts.push 1.6, { x: 2.0, y: 3.0 }
+  #   ts.push 1.9, { x: 2.0, y: 3.0 }
+  #   ts.push 2.1, { x: 2.0, y: 3.0 }
+  #
+  #   # more time-efficient batch insertion using arrays:
+  #   ts = TimeSeries.new
+  #   tt = [ 1.0, 1.2, 1.6, 1.9, 2.1 ]
+  #   dd = [ {x: 2.0}, {x: 2.1}, {x: 2.5}, {x: 2.7}, {x: 2.85} ]
+  #   ts.push_array(tt, dd)
+  #
+  #   # retrieve closest element before given time
+  #   ts[1.2] # => { x: 2.1 }
+  #   ts[2.095] # => { x: 2.7 }
+
+  class TimeSeries
+    attr_reader :data, :processor
+
+    # Creates a TimeSeries object.
+    #
+    # @param arr_t [Array<Float>] Array of timestamps
+    # @param arr_v [Array] Array of corresponding values, should be of the same size as +arr_t+
+    #
+    # == Examples:
+    #
+    #   ts = TimeSeries.new # creates empty TimeSeries object
+    #
+    #   ts = TimeSeries.new([0.1, 0.5, 1.0], [120.0, 130.0, 140.0])
+    #
+    def initialize(arr_t = nil, arr_v = nil)
+      @data = []
+      @processor = nil
+      push_array(arr_t, arr_v) if arr_t && arr_v
+    end
+
+    # @return number of values in the series
+    #
+    def size
+      @data.size
+    end
+
+    # @return [Array] Array of timestamps
+    #
+    def keys
+      @data.map { |d| d[0] }
+    end
+
+    # @return [Array] Array of values
+    #
+    def values
+      @data.map { |d| d[1] }
+    end
+
+    # @return [Array, nil] First element of the time series
+    #
+    def first
+      @data.first
+    end
+
+    # @return [Float, nil] Timestamp of the first element
+    #
+    def t_first
+      first && first[0]
+    end
+
+    # @return [Array, nil] Last element of the time series
+    #
+    def last
+      @data.last
+    end
+
+    # @return [Float, nil] Timestamp of the last element
+    #
+    def t_last
+      last && last[0]
+    end
+
+    # Inserts new element into time series.
+    # @param t [Float] Timestamp of the new value
+    # @param v [Fixnum, Float, Array, Hash] New value
+    #
+    def push(t, v)
+      t = t.to_f
+      i = left_index_at(t)
+      if i.nil?
+        @data.unshift([t, v])
+      else
+        @data.insert(i + 1, [t, v])
+      end
+    end
+
+    # Alias for #push(t, v)
+    #
+    # == Example:
+    #
+    #   ts = TimeSeries.new
+    #   ts[1.0] = { x: 123.0 }
+    #   ts[2.0] = { x: 125.0 }
+    #
+    #   ts[1.0] # => { x: 123.0 }
+    #
+    # @param (see #push)
+    #
+    def []=(t, v)
+      push(t, v)
+    end
+
+    # Inserts batch of new values into time series. This method is more time efficient
+    # than using #push to insert elements one by one.
+    #
+    # @param arr_t [Array] Array of timestamps
+    # @param arr_v [Array] Array of corresponding values, should be of the same size as +arr_t+
+    #
+    def push_array(arr_t, arr_v)
+      arr_data = arr_t.zip(arr_v)
+      @data.concat(arr_data)
+      @data.sort_by! { |d| d[0] }
+    end
+
+    # @return index of the element preceding +t+
+    #
+    def left_index_at(t)
+      indices_at(t).first
+    end
+
+    # Returns value calculated at +t+.
+    #
+    # The actual value returned depends on the +processor+
+    # used by TimeSeries object. When no +processor+ is used, the returned value is the value
+    # of the last element preceding, or exactly at +t+.
+    #
+    def [](t)
+      i = left_index_at(t)
+      i && @data[i][1]
+    end
+
+    # @return [Array] indices of the elements surrounding +t+.
+    #
+    def indices_at(t)
+      bsearch_indices_at(t)
+    end
+
+    # Use +processor+
+    #
+    def use(processor_module)
+      @processor = processor_module
+      extend processor_module
+    end
+  end # class TimeSeries
+end # module TimeSeriesMath

data/lib/time_series_math/version.rb

@@ -0,0 +1,3 @@
+module TimeSeriesMath
+  VERSION = "0.1.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'time_series_math'
+
+include TimeSeriesMath
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/time_series_math/elemwise_operators_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'ElemwiseOperators' do
+  class A
+  end
+
+  subject { A.new.extend(ElemwiseOperators) }
+
+  describe '#elemwise_add' do
+    it 'should add Fixnum' do
+      expect(subject.elemwise_add( 1.0, 2.0 )).to eql 3.0
+    end
+    it 'should add Array(s)' do
+      expect(subject.elemwise_add([1.0], [2.0])).to eql [3.0]
+    end
+    it 'should add Hash(es)' do
+      expect(subject.elemwise_add({ x: 1.0 }, { x: 2.0 })).to eql({ x: 3.0 })
+    end
+  end
+
+  describe '#elemwise_sub' do
+    it 'should substract Fixnum' do
+      expect(subject.elemwise_sub( 1.0, 2.0 )).to eql -1.0
+    end
+    it 'should substract Array(s)' do
+      expect(subject.elemwise_sub([1.0], [2.0])).to eql [-1.0]
+    end
+    it 'should substract Hash(es)' do
+      expect(subject.elemwise_sub({ x: 1.0 }, { x: 2.0 })).to eql({ x: -1.0 })
+    end
+  end
+
+  describe '#elemwise_mul_scalar' do
+    it 'should multiply Fixnum' do
+      expect(subject.elemwise_mul_scalar( 2.0, 3.0 )).to eql 6.0
+    end
+    it 'should multiply Array(s)' do
+      expect(subject.elemwise_mul_scalar(2.0, [3.0])).to eql [6.0]
+    end
+    it 'should mutiply Hash(es)' do
+      expect(subject.elemwise_mul_scalar(2.0, { x: 3.0 })).to eql({ x: 6.0 })
+    end
+  end
+end

data/spec/time_series_math/linear_interpolation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe LinearInterpolation do
+
+  let(:arr_t) { [1.0, 2.0, 3.0] }
+  let(:arr_v) { [100, 200, 300] }
+  let(:arr_v_a) { [[100], [200], [300]] }
+  let(:arr_v_h) { [{ x: 100 }, { x: 200 }, { x: 300 }] }
+  it { expect { TimeSeries.new.use(LinearInterpolation) }.to_not raise_error }
+
+  context 'when values are floats' do
+    subject { TimeSeries.new(arr_t, arr_v).use(LinearInterpolation) }
+    it { expect(subject[1.5]).to eql 150.to_f }
+  end
+
+  context 'when values are arrays' do
+    subject { TimeSeries.new(arr_t, arr_v_a).use(LinearInterpolation) }
+    it { expect(subject[1.5]).to eql [150.to_f] }
+  end
+
+  context 'when values are hashes' do
+    subject { TimeSeries.new(arr_t, arr_v_h).use(LinearInterpolation) }
+    it { expect(subject[1.5]).to eql({ x: 150.to_f }) }
+  end
+
+  context 'when requested value is out of range' do
+    subject { TimeSeries.new(arr_t, arr_v).use(LinearInterpolation) }
+    it { expect(subject[-1.0].to_f).to eql 100.to_f }
+    it { expect(subject[10.0].to_f).to eql 300.to_f }
+  end
+
+end

data/spec/time_series_math/time_series_math_c_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe TimeSeries do
+  it { should respond_to(:bsearch_indices_at) }
+  it { expect { subject.bsearch_indices_at(1.0) }.not_to raise_error }
+  it { expect(subject.bsearch_indices_at(1.0)).to eql [nil, nil] }
+
+  let(:arr_t)   { [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] }
+  let(:arr_t1)  { [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] }
+  let(:arr_t2)  { [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0] }
+  let(:arr_v)   { [111, 222, 333, 444, 555, 666, 777] }
+
+  context 'when initialized with arrays' do
+    subject { TimeSeries.new(arr_t, arr_v) }
+
+    describe '#bsearch_indices_at' do
+      it 'should return [nil, 0] if t < first element' do
+        expect(subject.bsearch_indices_at(-1.0)).to eql [nil, 0]
+      end
+      it 'should return [i_k, i_k+1] if T(i_k) <= t < T(i_k+1)' do
+        expect(subject.bsearch_indices_at(1.0)).to eql [0, 1]
+        expect(subject.bsearch_indices_at(1.5)).to eql [0, 1]
+      end
+      it 'should return last element index [N, nil] if T(N) <= t' do
+        expect(subject.bsearch_indices_at(10.0)).to eql [6, nil]
+      end
+    end
+  end
+
+  context 'when initialized with several items with same timestamp' do
+    let(:ts1) { TimeSeries.new(arr_t1, arr_v) }
+    let(:ts2) { TimeSeries.new(arr_t2, arr_v) }
+
+    describe '#bsearch_indices_at' do
+      it 'should return last element index pair [N, nil] if T(N) <= t' do
+        expect(ts1.bsearch_indices_at(1.0)).to eql [6, nil]
+        expect(ts1.bsearch_indices_at(10.0)).to eql [6, nil]
+      end
+      it 'should return index pair of last element in serie of equal timestamps' do
+        expect(ts2.bsearch_indices_at(1.0)).to eql [2, 3]
+      end
+    end
+  end
+end

data/spec/time_series_math/time_series_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe TimeSeries do
+  context 'when empty' do
+    subject { TimeSeries.new }
+    it { expect(subject.data).to eql [] }
+    it { expect(subject.first).to be nil }
+    it { expect(subject.last).to be nil }
+    it { expect(subject.t_first).to be nil }
+    it { expect(subject.t_last).to be nil }
+    it { expect(subject.size).to eql 0 }
+    it { expect(subject.keys).to eql [] }
+    it { expect(subject.values).to eql [] }
+    it { expect(subject.left_index_at(1.0)).to be nil }
+    it { expect(subject.indices_at(1.0)).to eql [nil, nil] }
+    it { expect(subject[1.0]).to be nil }
+  end
+
+  let(:arr_t)   { [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] }
+  let(:arr_t1)  { [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] }
+  let(:arr_t2)  { [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0] }
+  let(:arr_v)   { [111, 222, 333, 444, 555, 666, 777] }
+  it { expect { TimeSeries.new(arr_t, arr_v) }.to_not raise_error }
+
+  context 'when initialized with arrays' do
+    subject { TimeSeries.new(arr_t, arr_v) }
+    it { expect(subject.size).to eql 7 }
+    it { expect(subject.first).to eql [1.0, 111] }
+    it { expect(subject.last).to eql [7.0, 777] }
+    it { expect(subject.t_first).to eql 1.0 }
+    it { expect(subject.t_last).to eql 7.0 }
+
+    describe '#left_index_at' do
+      it 'should return nil if t < first element' do
+        expect(subject.left_index_at(-1.0)).to be nil
+      end
+      it 'should return i_k if T(i_k) <= t < T(i_k+1)' do
+        expect(subject.left_index_at(1.0)).to be 0
+        expect(subject.left_index_at(1.5)).to be 0
+      end
+      it 'should return last element index (N) if T(N) <= t' do
+        expect(subject.left_index_at(10.0)).to be 6
+      end
+    end
+
+    describe '#[]' do
+      it 'should return nil if t < first element' do
+        expect(subject[-1.0]).to be nil
+      end
+      it 'should return i_k if T(i_k) <= t < T(i_k+1)' do
+        expect(subject[1.0]).to be 111
+        expect(subject[1.5]).to be 111
+      end
+      it 'should return last element index (N) if T(N) <= t' do
+        expect(subject[10.0]).to be 777
+      end
+    end
+  end
+
+  context 'when initialized with several items with same timestamp' do
+    let(:ts1) { TimeSeries.new(arr_t1, arr_v) }
+    let(:ts2) { TimeSeries.new(arr_t2, arr_v) }
+
+    describe '#left_index_at' do
+      it 'should return last element index (N) if T(N) <= t' do
+        expect(ts1.left_index_at(1.0)).to be 6
+        expect(ts1.left_index_at(10.0)).to be 6
+      end
+      it 'should return index of last element in serie of equal timestamps' do
+        expect(ts2.left_index_at(1.0)).to be 2
+      end
+    end
+
+    describe '#indices_at' do
+      it 'should return last element index pair [N, nil] if T(N) <= t' do
+        expect(ts1.indices_at(1.0)).to eql [6, nil]
+        expect(ts1.indices_at(10.0)).to eql [6, nil]
+      end
+      it 'should return index pair of last element in serie of equal timestamps' do
+        expect(ts2.indices_at(1.0)).to eql [2, 3]
+      end
+    end
+  end
+
+  context 'when adding new items' do
+    subject { TimeSeries.new(arr_t, arr_v) }
+    it 'should place new items at correct place' do
+      expect { subject.push(1.5, 123) }.to_not raise_error
+      expect(subject.keys).to eql [1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
+    end
+    it 'should allow []= syntax' do
+      expect { subject[1.5] = 123 }.to_not raise_error
+      expect(subject.keys).to eql [1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
+    end
+  end
+
+end

data/spec/time_series_math/time_series_use_api_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe TimeSeries do
+  module TimeSeriesTestProcessor
+  end
+
+  it { should respond_to(:use) }
+  it { should respond_to(:processor) }
+  it { expect(subject.processor).to be nil }
+  it { expect(subject.use(TimeSeriesTestProcessor)).to eql subject }
+
+  context 'when using a processor' do
+    subject { TimeSeries.new.use(TimeSeriesTestProcessor) }
+    it { expect(subject.processor).to eql TimeSeriesTestProcessor }
+  end
+end

data/spec/time_series_math_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe TimeSeriesMath do
+  # it { should have_const(TimeSeries) }
+end

data/time_series_math.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'time_series_math/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "time_series_math"
+  spec.version       = TimeSeriesMath::VERSION
+  spec.authors       = ["Alex Kukushkin"]
+  spec.email         = ["alex@kukushk.in"]
+  spec.summary       = %q{Simple time series math}
+  spec.description   = %q{Time series math support}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "ext"]
+
+  spec.extensions    = Dir['ext/**/extconf.rb']
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake-compiler"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: time_series_math
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alex Kukushkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Time series math support
+email:
+- alex@kukushk.in
+executables: []
+extensions:
+- ext/time_series_math_c/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/ts_benchmark.rb
+- ext/time_series_math_c/extconf.rb
+- ext/time_series_math_c/time_series_math_c.c
+- lib/time_series_math.rb
+- lib/time_series_math/elemwise_operators.rb
+- lib/time_series_math/linear_interpolation.rb
+- lib/time_series_math/time_series.rb
+- lib/time_series_math/version.rb
+- spec/spec_helper.rb
+- spec/time_series_math/elemwise_operators_spec.rb
+- spec/time_series_math/linear_interpolation_spec.rb
+- spec/time_series_math/time_series_math_c_spec.rb
+- spec/time_series_math/time_series_spec.rb
+- spec/time_series_math/time_series_use_api_spec.rb
+- spec/time_series_math_spec.rb
+- time_series_math.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple time series math
+test_files:
+- spec/spec_helper.rb
+- spec/time_series_math/elemwise_operators_spec.rb
+- spec/time_series_math/linear_interpolation_spec.rb
+- spec/time_series_math/time_series_math_c_spec.rb
+- spec/time_series_math/time_series_spec.rb
+- spec/time_series_math/time_series_use_api_spec.rb
+- spec/time_series_math_spec.rb
+has_rdoc: