daru_lite 0.1

data/spec/maths/statistics/vector_spec.rb

@@ -0,0 +1,756 @@
+describe DaruLite::Vector do
+  describe 'array' do
+    let(:dtype) { :array }
+
+    before do
+      @dv = DaruLite::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2], dtype: dtype
+      @dv_with_nils = DaruLite::Vector.new [323, 11, 555, nil, 666, 234, 21, 666, 343, nil, 1, 2]
+    end
+
+    context "#mean" do
+      it "calculates mean" do
+        expect(@dv.mean).to eq(282.2)
+      end
+    end
+
+    let(:dv) { dv = DaruLite::Vector.new (["Tyrion", "Daenerys", nil, "Jon Starkgaryen"]), index: DaruLite::Index.new([:t, :d, :n, :j]) }
+
+    context "#max" do
+      it "returns max value" do
+        expect(dv.max).to eq("Tyrion")
+      end
+      it "returns N max values" do
+        expect(dv.max(2)).to eq(["Tyrion","Jon Starkgaryen"])
+      end
+      it "returns max value, sorted by comparitive block input" do
+        expect(dv.max { |a,b| a.size <=> b.size }).to eq("Jon Starkgaryen")
+      end
+      it "returns N max values, sorted by comparitive block input" do
+        expect(dv.max(2) {|a,b| a.size <=> b.size}).to eq(["Jon Starkgaryen","Daenerys"])
+      end
+    end
+
+    context "#max_by" do
+      it "raises error without object block" do
+        expect { dv.max_by }.to raise_error(ArgumentError)
+      end
+      it "raises error without object block when N is given" do
+        expect { dv.max_by(2) }.to raise_error(ArgumentError)
+      end
+      it "returns max value, sorted by object block input" do
+        expect(dv.max_by { |x| x.size }).to eq("Jon Starkgaryen")
+      end
+      it "returns N max values, sorted by object block input" do
+        expect(dv.max_by(2) {|x| x.size }).to eq(["Jon Starkgaryen","Daenerys"])
+      end
+    end
+
+    context "#index_of_max" do
+      it "returns index_of_max value" do
+        expect(dv.index_of_max).to eq(:t)
+      end
+      it "returns N index_of_max values" do
+        expect(dv.index_of_max(2)).to eq([:t, :j])
+      end
+      it "returns index_of_max value, sorted by comparitive block input" do
+        expect(dv.index_of_max { |a,b| a.size <=> b.size }).to eq(:j)
+      end
+      it "returns N index_of_max values, sorted by comparitive block input" do
+        expect(dv.index_of_max(2) {|a,b| a.size <=> b.size}).to eq([:j, :d])
+      end
+    end
+
+    context "#index_of_max_by" do
+      it "raises error without object block" do
+        expect { dv.index_of_max_by }.to raise_error(ArgumentError)
+      end
+      it "raises error without object block when N is given" do
+        expect { dv.index_of_max_by(2) }.to raise_error(ArgumentError)
+      end
+      it "returns index_of_max value, sorted by object block input" do
+        expect(dv.index_of_max_by { |x| x.size }).to eq(:j)
+      end
+      it "returns N index_of_max values, sorted by object block input" do
+        expect(dv.index_of_max_by(2) {|x| x.size }).to eq([:j, :d])
+      end
+    end
+
+    context "#min" do
+      it "returns min value" do
+        expect(dv.min).to eq("Daenerys")
+      end
+      it "returns N min values" do
+        expect(dv.min(2)).to eq(["Daenerys","Jon Starkgaryen"])
+      end
+      it "returns min value, sorted by comparitive block input" do
+        expect(dv.min { |a,b| a.size <=> b.size }).to eq("Tyrion")
+      end
+      it "returns N min values, sorted by comparitive block input" do
+        expect(dv.min(2) {|a,b| a.size <=> b.size}).to eq(["Tyrion","Daenerys"])
+      end
+    end
+
+    context "#min_by" do
+      it "raises error without object block" do
+        expect { dv.min_by }.to raise_error(ArgumentError)
+      end
+      it "raises error without object block when N is given" do
+        expect { dv.min_by(2) }.to raise_error(ArgumentError)
+      end
+      it "returns min value, sorted by object block input" do
+        expect(dv.min_by { |x| x.size }).to eq("Tyrion")
+      end
+      it "returns N min values, sorted by object block input" do
+        expect(dv.min_by(2) {|x| x.size }).to eq(["Tyrion","Daenerys"])
+      end
+    end
+
+    context "#index_of_min" do
+      it "returns index of min value" do
+        expect(dv.index_of_min).to eq(:d)
+      end
+      it "returns N index of min values" do
+        expect(dv.index_of_min(2)).to eq([:d, :j])
+      end
+      it "returns index of min value, sorted by comparitive block input" do
+        expect(dv.index_of_min { |a,b| a.size <=> b.size }).to eq(:t)
+      end
+      it "returns N index of min values, sorted by comparitive block input" do
+        expect(dv.index_of_min(2) {|a,b| a.size <=> b.size}).to eq([:t, :d])
+      end
+    end
+
+    context "#index_of_min_by" do
+      it "raises error without object block" do
+        expect { dv.index_of_min_by }.to raise_error(ArgumentError)
+      end
+      it "raises error without object block when N is given" do
+        expect { dv.index_of_min_by(2) }.to raise_error(ArgumentError)
+      end
+      it "returns index of min value, sorted by object block input" do
+        expect(dv.index_of_min_by { |x| x.size }).to eq(:t)
+      end
+      it "returns N index of min values, sorted by object block input" do
+        expect(dv.index_of_min_by(2) {|x| x.size }).to eq([:t, :d])
+      end
+    end
+
+    context "#sum_of_squares" do
+      it "calcs sum of squares, omits nil values" do
+        v = DaruLite::Vector.new [1,2,3,4,5,6], dtype: dtype
+        expect(v.sum_of_squares).to eq(17.5)
+      end
+    end
+
+    context "#standard_deviation_sample" do
+      it "calcs standard deviation sample" do
+        @dv_with_nils.standard_deviation_sample
+      end
+    end
+
+    context "#variance_sample" do
+      it "calculates sample variance" do
+        expect(@dv.variance).to be_within(0.01).of(75118.84)
+      end
+    end
+
+    context "#standard_deviation_population" do
+      it "calculates standard deviation population" do
+        @dv.standard_deviation_population
+      end
+    end
+
+    context "#variance_population" do
+      it "calculates population variance" do
+        expect(@dv.variance_population).to be_within(0.001).of(67606.95999999999)
+      end
+    end
+
+    context "#covariance_sample" do
+      it "calculates sample covariance" do
+        @dv_1 = DaruLite::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2]
+        @dv_2 = DaruLite::Vector.new [123, 22, 444, 555, 324, 21, 666, 434, 5, 8]
+        expect(@dv_1.covariance @dv_2).to be_within(0.00001).of(65603.62222)
+      end
+    end
+
+    context "#covariance_population" do
+      it "calculates population covariance" do
+        @dv_1 = DaruLite::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2]
+        @dv_2 = DaruLite::Vector.new [123, 22, 444, 555, 324, 21, 666, 434, 5, 8]
+        expect(@dv_1.covariance_population @dv_2).to be_within(0.01).of(59043.26)
+      end
+    end
+
+    context "#sum_of_squared_deviation" do
+      it "calculates sum of squared deviation" do
+        expect(@dv.sum_of_squared_deviation).to eq(676069.6)
+      end
+    end
+
+    context "#skew" do
+      it "calculates skewness" do
+        @dv.skew
+      end
+    end
+
+    context "#max" do
+      it "returns the max value" do
+        expect(@dv.max).to eq(666)
+      end
+    end
+
+    context "#min" do
+      it "returns the min value" do
+        expect(@dv.min).to eq(1)
+      end
+    end
+
+    context "#sum" do
+      it "returns the sum" do
+        expect(@dv.sum).to eq(2822)
+      end
+    end
+
+    context "#product" do
+      it "returns the product" do
+        v = DaruLite::Vector.new [1, 2, 3, 4, 5], dtype: dtype
+        expect(v.product).to eq(120)
+      end
+    end
+
+    context "#median" do
+      it "returns the median" do
+        @dv.median
+      end
+    end
+
+    context "#mode" do
+      it "returns the single modal value as a numeric" do
+        mode_test_example = DaruLite::Vector.new [1,2,3,2,4,4,4,4], dtype: dtype
+        expect(mode_test_example.mode).to eq(4)
+      end
+
+      it "returns multiple modal values as a vector" do
+        mode_test_example = DaruLite::Vector.new [1,2,2,2,3,2,4,4,4,4], dtype: dtype
+        expect(mode_test_example.mode).to eq(DaruLite::Vector.new [2,4], dtype: dtype)
+      end
+    end
+
+    context "#describe" do
+      it "generates count, mean, std, min and max of vectors in one shot" do
+        expect(@dv.describe.round(2)).to eq(DaruLite::Vector.new([10.00, 282.20, 274.08, 1.00, 666.00],
+          index: [:count, :mean, :std, :min, :max],
+          name:  :statistics
+        ))
+      end
+    end
+
+    context "#kurtosis" do
+      it "calculates kurtosis" do
+        @dv.kurtosis
+      end
+    end
+
+    context "#count" do
+      it "counts specified element" do
+        expect(@dv.count(323)).to eq(1)
+      end
+
+      it "counts total number of elements" do
+        expect(@dv.count).to eq(10)
+      end
+
+      it "counts by block provided" do
+        expect(@dv.count{|e| e.to_i.even? }).to eq(4)
+      end
+    end
+
+    context "#value_counts" do
+      it "counts number of unique values in the Vector" do
+        vector = DaruLite::Vector.new(
+          ["America","America","America","America","America",
+            "India","India", "China", "India", "China"])
+        expect(vector.value_counts).to eq(
+          DaruLite::Vector.new([5,3,2], index: ["America", "India", "China"]))
+      end
+    end
+
+    context "#coefficient_of_variation" do
+      it "calculates coefficient_of_variation" do
+        @dv.coefficient_of_variation
+      end
+    end
+
+    context "#percentile" do
+      it "calculates mid point percentile" do
+        expect(@dv.percentile(50)).to eq(278.5)
+      end
+
+      it "calculates linear percentile" do
+        # FIXME: Not enough testing?..
+        expect(@dv.percentile(50, :linear)).to eq(278.5)
+      end
+
+      it "fails on unknown strategy" do
+        expect { @dv.percentile(50, :killemall) }.to raise_error(ArgumentError, /strategy/)
+      end
+    end
+
+    context "#average_deviation_population" do
+      it "calculates average_deviation_population" do
+        a = DaruLite::Vector.new([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype: dtype)
+        expect(a.average_deviation_population).to eq(20.quo(9).to_f)
+      end
+    end
+
+    context "#proportion" do
+      it "calculates proportion" do
+        expect(@dv.proportion(1)).to eq(0.1)
+      end
+    end
+
+    context "#proportions" do
+      it "calculates proportions" do
+        actual_proportions = {
+          323=>0.1,11=>0.1,555=>0.1,666=>0.2,234=>0.1,21=>0.1,343=>0.1,1=>0.1,2=>0.1
+        }
+        expect(@dv.proportions).to eq(actual_proportions)
+      end
+    end
+
+    context "#standard_error" do
+      it "calculates standard error" do
+        @dv.standard_error
+      end
+    end
+
+    context "#vector_standardized_compute" do
+      it "calculates vector_standardized_compute" do
+        @dv.vector_standardized_compute(@dv.mean, @dv.sd)
+        @dv_with_nils.vector_standardized_compute(@dv.mean, @dv.sd)
+      end
+    end
+
+    context "#vector_centered_compute" do
+      it "calculates vector_centered_compute" do
+        @dv.vector_centered_compute(@dv.mean)
+        @dv_with_nils.vector_centered_compute(@dv.mean)
+      end
+    end
+  end
+
+  # Only Array tests
+  context "#percentile" do
+    it "tests linear percentile strategy" do
+      values = DaruLite::Vector.new [102, 104, 105, 107, 108, 109, 110, 112, 115, 116].shuffle
+      expect(values.percentil(0, :linear)).to eq(102)
+      expect(values.percentil(25, :linear)).to eq(104.75)
+      expect(values.percentil(50, :linear)).to eq(108.5)
+      expect(values.percentil(75, :linear)).to eq(112.75)
+      expect(values.percentil(100, :linear)).to eq(116)
+
+      values = DaruLite::Vector.new [102, 104, 105, 107, 108, 109, 110, 112, 115, 116, 118].shuffle
+      expect(values.percentil(0, :linear)).to eq(102)
+      expect(values.percentil(25, :linear)).to eq(105)
+      expect(values.percentil(50, :linear)).to eq(109)
+      expect(values.percentil(75, :linear)).to eq(115)
+      expect(values.percentil(100, :linear)).to eq(118)
+    end
+  end
+
+  context "#frequencies" do
+    let(:vector) { DaruLite::Vector.new([5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99]) }
+    subject { vector.frequencies }
+    it { is_expected.to eq DaruLite::Vector.new(
+      [5,2,1,1,1,1,1,1,1,1,2],
+      index: [5,6,7,8,9,10,1,2,3,4,-99]
+    )}
+  end
+
+  context "#ranked" do
+    it "curates by rank" do
+      vector = DaruLite::Vector.new([nil, 0.8, 1.2, 1.2, 2.3, 18, nil])
+      expect(vector.ranked).to eq(DaruLite::Vector.new([nil,1,2.5,2.5,4,5,nil]))
+
+      v = DaruLite::Vector.new [0.8, 1.2, 1.2, 2.3, 18]
+      expect(v.ranked).to eq(DaruLite::Vector.new [1, 2.5, 2.5, 4, 5])
+    end
+
+    it "tests paired ties" do
+      a = DaruLite::Vector.new [0, 0, 0, 1, 1, 2, 3, 3, 4, 4, 4]
+      expected = DaruLite::Vector.new [2, 2, 2, 4.5, 4.5, 6, 7.5, 7.5, 10, 10, 10]
+      expect(a.ranked).to eq(expected)
+    end
+  end
+
+  context "#dichotomize" do
+    it "dichotomizes" do
+      a = DaruLite::Vector.new [0, 0, 0, 1, 2, 3, nil]
+      exp = DaruLite::Vector.new [0, 0, 0, 1, 1, 1, nil]
+      expect(a.dichotomize).to eq(exp)
+
+      a = DaruLite::Vector.new [1, 1, 1, 2, 2, 2, 3]
+      exp = DaruLite::Vector.new [0, 0, 0, 1, 1, 1, 1]
+      expect(a.dichotomize).to eq(exp)
+
+      a = DaruLite::Vector.new [0, 0, 0, 1, 2, 3, nil]
+      exp = DaruLite::Vector.new [0, 0, 0, 0, 1, 1, nil]
+      expect(a.dichotomize(1)).to eq(exp)
+
+      a = DaruLite::Vector.new %w(a a a b c d)
+      exp = DaruLite::Vector.new [0, 0, 0, 1, 1, 1]
+      expect(a.dichotomize).to eq(exp)
+    end
+  end
+
+  context "#median_absolute_deviation" do
+    it "calculates median_absolute_deviation" do
+      a = DaruLite::Vector.new [1, 1, 2, 2, 4, 6, 9]
+      expect(a.median_absolute_deviation).to eq(1)
+    end
+  end
+
+  context "#round" do
+    it "rounds non-nil values" do
+      vector = DaruLite::Vector.new([1.44,55.32,nil,4])
+      expect(vector.round(1)).to eq(DaruLite::Vector.new([1.4,55.3,nil,4]))
+    end
+  end
+
+  context "#center" do
+    it "centers" do
+      mean = rand
+      samples = 11
+      centered = DaruLite::Vector.new(samples.times.map { |i| i - ((samples / 2).floor).to_i })
+      not_centered = centered.recode { |v| v + mean }
+      obs = not_centered.center
+      centered.each_with_index do |v, i|
+        expect(v).to be_within(0.0001).of(obs[i])
+      end
+    end
+  end
+
+  context "#standardize" do
+    it "returns a standardized vector" do
+      vector = DaruLite::Vector.new([11,55,33,25,nil,22])
+      expect(vector.standardize.round(2)).to eq(
+        DaruLite::Vector.new([-1.11, 1.57, 0.23, -0.26,nil, -0.44])
+        )
+    end
+
+    it "tests for vector standardized with zero variance" do
+      v1 = DaruLite::Vector.new 100.times.map { |_i| 1 }
+      exp = DaruLite::Vector.new 100.times.map { nil }
+      expect(v1.standardize).to eq(exp)
+    end
+  end
+
+  context "#vector_percentile" do
+    it "replaces each non-nil value with its percentile value" do
+      vector = DaruLite::Vector.new([1,nil,nil,2,2,3,4,nil,nil,5,5,5,6,10])
+      expect(vector.vector_percentile).to eq(DaruLite::Vector.new(
+        [10,nil,nil,25,25,40,50,nil,nil,70,70,70,90,100])
+      )
+    end
+  end
+
+  context "#sample_with_replacement" do
+    it "calculates sample_with_replacement" do
+      vec =  DaruLite::Vector.new(
+        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99],
+        name: :common_all_dtypes)
+      srand(1)
+      expect(vec.sample_with_replacement(100).size).to eq(100)
+
+      srand(1)
+      expect(vec.sample_with_replacement(100).size).to eq(100)
+    end
+  end
+
+  context "#sample_without_replacement" do
+    it "calculates sample_without_replacement" do
+      vec =  DaruLite::Vector.new(
+        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99],
+        name: :common_all_dtypes)
+
+      srand(1)
+      expect(vec.sample_without_replacement(17).sort).to eq(
+        vec.reject_values(*DaruLite::MISSING_VALUES).to_a.sort)
+      expect {
+        vec.sample_without_replacement(20)
+      }.to raise_error(ArgumentError)
+
+      srand(1)
+      expect(vec.sample_without_replacement(17).sort).to eq(
+        vec.reject_values(*DaruLite::MISSING_VALUES).to_a.sort)
+    end
+  end
+
+  context "#jackknife" do
+    it "jack knife correctly with named method" do
+      a = DaruLite::Vector.new [1, 2, 3, 4]
+      df = a.jackknife(:mean)
+      expect(df[:mean].mean).to eq (a.mean)
+
+      df = a.jackknife([:mean, :sd])
+      expect(df[:mean].mean).to eq(a.mean)
+      expect(df[:mean].sd).to eq(a.sd)
+    end
+
+    it "jack knife correctly with custom method" do
+      a   = DaruLite::Vector.new [17.23, 18.71, 13.93, 18.81, 15.78, 11.29, 14.91, 13.39, 18.21, 11.57, 14.28, 10.94, 18.83, 15.52, 13.45, 15.25]
+      ds  = a.jackknife(log_s2: ->(v) {  Math.log(v.variance) })
+      exp = DaruLite::Vector.new [1.605, 2.972, 1.151, 3.097, 0.998, 3.308, 0.942, 1.393, 2.416, 2.951, 1.043, 3.806, 3.122, 0.958, 1.362, 0.937]
+
+      expect_correct_vector_in_delta ds[:log_s2], exp, 0.001
+      # expect(ds[:log_s2]).to be_within(0.001).of(exp)
+      expect(ds[:log_s2].mean).to be_within(0.00001).of(2.00389)
+      expect(ds[:log_s2].variance).to be_within(0.001).of(1.091)
+    end
+
+    it "jack knife correctly with k > 1" do
+      rng = Distribution::Normal.rng(0,1)
+      a   = DaruLite::Vector.new_with_size(6) { rng.call}
+
+      ds = a.jackknife(:mean, 2)
+      mean = a.mean
+      exp = DaruLite::Vector.new [3 * mean - 2 * (a[2] + a[3] + a[4] + a[5]) / 4, 3 * mean - 2 * (a[0] + a[1] + a[4] + a[5]) / 4, 3 * mean - 2 * (a[0] + a[1] + a[2] + a[3]) / 4]
+      expect_correct_vector_in_delta(exp, ds[:mean], 1e-13)
+    end
+  end
+
+  before do
+    # daily closes of iShares XIU on the TSX
+    @shares = DaruLite::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
+  end
+
+  context "#acf" do
+    it "calculates autocorrelation co-efficients" do
+      acf = @shares.acf
+
+      expect(acf.length).to eq(14)
+
+      # test the first few autocorrelations
+      expect(acf[0]).to be_within(0.0001).of(1.0)
+      expect(acf[1]).to be_within(0.001) .of(0.852)
+      expect(acf[2]).to be_within(0.001) .of(0.669)
+      expect(acf[3]).to be_within(0.001) .of(0.486)
+    end
+  end
+
+  context "#percent_change" do
+    it "calculates percent change" do
+      vector = DaruLite::Vector.new([4,6,6,8,10],index: ['a','f','t','i','k'])
+      expect(vector.percent_change).to eq(
+      DaruLite::Vector.new([nil, 0.5, 0.0, 0.3333333333333333, 0.25], index: ['a','f','t','i','k']))
+    end
+
+    it "tests for numerical vectors with nils" do
+      vector2 = DaruLite::Vector.new([nil,6,nil,8,10],index: ['a','f','t','i','k'])
+      expect(vector2.percent_change).to eq(
+      DaruLite::Vector.new([nil, nil, nil, 0.3333333333333333, 0.25], index: ['a','f','t','i','k']))
+    end
+  end
+
+  context "#diff" do
+    it "performs the difference of the series" do
+      diff = @shares.diff
+
+      expect(diff.class).to eq(DaruLite::Vector)
+      expect(diff[@shares.size - 1]).to be_within(0.001).of( 0.11)
+      expect(diff[@shares.size - 2]).to be_within(0.001).of( 0.30)
+      expect(diff[@shares.size - 3]).to be_within(0.001).of(-0.20)
+    end
+  end
+
+  context "#rolling" do
+    it "calculates rolling mean" do
+      ma10 = @shares.rolling_mean
+
+      expect(ma10[-1]) .to be_within(0.001).of(16.897)
+      expect(ma10[-5]) .to be_within(0.001).of(17.233)
+      expect(ma10[-10]).to be_within(0.001).of(17.587)
+
+      # test with a different lookback period
+      ma5 = @shares.rolling :mean, 5
+
+      expect(ma5[-1]).to be_within(0.001).of(16.642)
+      expect(ma5[-10]).to be_within(0.001).of(17.434)
+      expect(ma5[-15]).to be_within(0.001).of(17.74)
+    end
+
+    it "calculates rolling median" do
+      me10 = @shares.rolling_median.round(2)
+      expect(me10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.525,17.525,17.525,17.475,17.430,17.380,17.330,17.165,17.020,16.94,16.860]).round(2))
+
+      me5 = @shares.rolling(:median, 5).round(2)
+      expect(me5).to eq(DaruLite::Vector.new([nil,nil,nil,nil,17.74,17.82,17.82,17.74,17.56,17.49,17.46,17.46,17.46,17.40,17.03,17.01,16.86,16.86,16.66,16.66]))
+    end
+
+    it "calculates rolling max" do
+      max10 = @shares.rolling_max.round(2)
+      expect(max10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.85,17.85,17.85,17.85,17.85,17.85,17.56,17.56,17.56,17.49,17.46]))
+
+      max5 = @shares.rolling(:max, 5).round(2)
+      expect(max5).to eq(DaruLite::Vector.new([nil,  nil,  nil,  nil,17.84,17.85,17.85,17.85,17.85,17.85,17.56,17.56,17.56,17.49,17.46,17.40,17.03,17.01,16.86,16.86]))
+    end
+
+    it "calculates rolling min" do
+      min10 = @shares.rolling_min.round(2)
+      expect(min10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.28,17.30,17.30,17.03,17.01,16.86,16.86,16.56,16.36,16.36,16.36]))
+
+      min5 = @shares.rolling(:min, 5).round(2)
+      expect(min5).to eq(DaruLite::Vector.new([nil,nil,nil,nil,17.28,17.45,17.36,17.30,17.30,17.30,17.30,17.30,17.03,17.01,16.86,16.86,16.56,16.36,16.36,16.36]))
+    end
+
+    it "calculates rolling sum" do
+      sum10 = @shares.rolling_sum.round(2)
+      expect(sum10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,175.69,175.87,175.82,175.01,174.28,173.32,172.33,171.53,170.59,169.69,168.97]))
+
+      sum5 = @shares.rolling(:sum, 5).round(2)
+      expect(sum5).to eq(DaruLite::Vector.new([nil,nil,nil,nil,88.13,88.70,88.61,88.07,87.89,87.56,87.17,87.21,86.94,86.39,85.76,85.16,84.32,83.65,83.30,83.21]))
+    end
+
+    it "calculates rolling std" do
+      std10 = @shares.rolling_std.round(2)
+      expect(std10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,0.227227,0.208116,0.212331,0.253485,0.280666,0.295477,0.267127,0.335826,0.412834,0.388886,0.345995]).round(2))
+
+      std5 = @shares.rolling(:std, 5).round(2)
+      expect(std5).to eq(DaruLite::Vector.new([nil,nil,nil,nil,0.248556,0.167780,0.206930,0.263211,0.253811,0.215105,0.103827,0.098082,0.208255,0.237844,0.263002,0.220839,0.187963,0.263629,0.212132,0.193959]).round(2))
+    end
+
+    it "calculates rolling variance" do
+      var10 = @shares.rolling_variance.round(2)
+      expect(var10).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,0.051632,0.043312,0.045084,0.064254,0.078773,0.087307,0.071357,0.112779,0.170432,0.151232,0.119712]).round(2))
+
+      var5 = @shares.rolling(:variance, 5).round(2)
+      expect(var5).to eq(DaruLite::Vector.new([nil,nil,nil,nil,0.06178,0.02815,0.04282,0.06928,0.06442,0.04627,0.01078,0.00962,0.04337,0.05657,0.06917,0.04877,0.03533,0.06950,0.04500,0.03762]).round(2))
+    end
+
+    it "calculates rolling non-nil count" do
+      @shares.rolling_count
+    end
+  end
+
+  context "#ema" do
+    it "calculates exponential moving average" do
+      # test default
+      ema10 = @shares.ema
+
+      expect(ema10[-1]) .to be_within(0.00001).of( 16.87187)
+      expect(ema10[-5]) .to be_within(0.00001).of( 17.19187)
+      expect(ema10[-10]).to be_within(0.00001).of( 17.54918)
+
+      # test with a different loopback period
+      ema5 = @shares.ema 5
+
+      expect(ema5[-1]) .to be_within( 0.00001).of(16.71299)
+      expect(ema5[-10]).to be_within( 0.00001).of(17.49079)
+      expect(ema5[-15]).to be_within( 0.00001).of(17.70067)
+
+      # test with a different smoother
+      ema_w = @shares.ema 10, true
+
+      expect(ema_w[-1]) .to be_within(0.00001).of(17.08044)
+      expect(ema_w[-5]) .to be_within(0.00001).of(17.33219)
+      expect(ema_w[-10]).to be_within(0.00001).of(17.55810)
+    end
+  end
+
+  context "#emv" do
+    it "calculates exponential moving variance" do
+      # test default
+      emv10 = @shares.emv
+
+      expect(emv10[-1]) .to be_within(0.00001).of(0.14441)
+      expect(emv10[-5]) .to be_within(0.00001).of(0.10797)
+      expect(emv10[-10]).to be_within(0.00001).of(0.03979)
+
+      # test with a different loopback period
+      emv5 = @shares.emv 5
+
+      expect(emv5[-1]) .to be_within(0.00001).of(0.05172)
+      expect(emv5[-10]).to be_within(0.00001).of(0.01736)
+      expect(emv5[-15]).to be_within(0.00001).of(0.04410)
+
+      # test with a different smoother
+      emv_w = @shares.emv 10, true
+
+      expect(emv_w[-1]) .to be_within(0.00001).of(0.20318)
+      expect(emv_w[-5]) .to be_within(0.00001).of(0.11319)
+      expect(emv_w[-10]).to be_within(0.00001).of(0.04289)
+    end
+  end
+
+  context "#emsd" do
+    it "calculates exponential moving standard deviation" do
+      # test default
+      emsd10 = @shares.emsd
+
+      expect(emsd10[-1]) .to be_within(0.00001).of(0.38002)
+      expect(emsd10[-5]) .to be_within(0.00001).of(0.32859)
+      expect(emsd10[-10]).to be_within(0.00001).of(0.19947)
+
+      # test with a different loopback period
+      emsd5 = @shares.emsd 5
+
+      expect(emsd5[-1]) .to be_within(0.00001).of(0.22742)
+      expect(emsd5[-10]).to be_within(0.00001).of(0.13174)
+      expect(emsd5[-15]).to be_within(0.00001).of(0.21000)
+
+      # test with a different smoother
+      emsd_w = @shares.emsd 10, true
+
+      expect(emsd_w[-1]) .to be_within(0.00001).of(0.45076)
+      expect(emsd_w[-5]) .to be_within(0.00001).of(0.33644)
+      expect(emsd_w[-10]).to be_within(0.00001).of(0.20710)
+    end
+  end
+
+  RSpec.shared_examples 'correct macd' do |*args|
+    let(:source) { DaruLite::DataFrame.from_csv('spec/fixtures/macd_data.csv') }
+
+    # skip initial records during compare as ema is sensitive to
+    # period used.
+    # http://ta-lib.org/d_api/ta_setunstableperiod.html
+    let(:stability_offset) { 90 }
+    let(:delta) { 0.001 }
+    let(:desc) { args.empty? ? '12_26_9' : args.join('_') }
+
+    subject { source['price'].macd(*args) }
+
+    %w[ macd macdsig macdhist ].each_with_index do |field, i|
+      it do
+        act = subject[i][stability_offset..-1]
+        exp = source["#{field}_#{desc}"][stability_offset..-1]
+        expect(act).to be_all_within(delta).of(exp)
+      end
+    end
+  end
+
+  describe '#macd' do
+    context 'by default' do
+      it_should_behave_like 'correct macd'
+    end
+
+    context 'custom values for fast, slow, signal' do
+      it_should_behave_like 'correct macd', 6, 13, 4
+    end
+
+  end
+
+  context "#cumsum" do
+    it "calculates cumulative sum" do
+      vector = DaruLite::Vector.new([1,2,3,4,5,6,7,8,9,10])
+      expect(vector.cumsum).to eq(
+        DaruLite::Vector.new([1,3,6,10,15,21,28,36,45,55]))
+    end
+
+    it "works with missing values" do
+      vector = DaruLite::Vector.new([1,2,nil,3,nil,4,5])
+      expect(vector.cumsum).to eq(
+        DaruLite::Vector.new([1,3,nil,6,nil,10,15]))
+    end
+  end
+end