daru 0.1.2 → 0.1.3

data/spec/index_spec.rb

@@ -37,6 +37,16 @@ describe Daru::Index do
       expect(idx.to_a).to eq(['speaker', 'mic', 'guitar', 'amp'])
     end
 
+    it "creates an Index from Range" do
+      idx = Daru::Index.new 1..5
+
+      expect(idx).to eq(Daru::Index.new [1, 2, 3, 4, 5])
+    end
+
+    it "raises ArgumentError on invalid input type" do
+      expect { Daru::Index.new 'foo' }.to raise_error ArgumentError
+    end
+
     it "accepts all sorts of objects for Indexing" do
       idx = Daru::Index.new [:a, 'a', :hello, '23', 23]
 
@@ -76,7 +86,7 @@ describe Daru::Index do
   context "#[]" do
     before do
       @id = Daru::Index.new [:one, :two, :three, :four, :five, :six, :seven]
-      @mixed_id = Daru::Index.new ['a','b','c',:d,:a,0,3,5]
+      @mixed_id = Daru::Index.new ['a','b','c',:d,:a,8,3,5]
     end
 
     it "works with ranges" do
@@ -88,12 +98,12 @@ describe Daru::Index do
       expect(@mixed_id[0..2]).to eq(Daru::Index.new(['a','b','c']))
 
       # If atleast one is a number then refer to actual indexing
-      expect(@mixed_id.slice('b',0)).to eq(Daru::Index.new(['b','c',:d,:a,0]))
+      expect(@mixed_id.slice('b',8)).to eq(Daru::Index.new(['b','c',:d,:a,8]))
     end
 
     it "returns multiple keys if specified multiple indices" do
-      expect(@id[0,1,3,4]).to eq(Daru::Index.new([0,1,3,4]))
-      expect(@mixed_id[0,5,3,2]).to eq(Daru::Index.new([5, 7, 6, 2]))
+      expect(@id[0,1,3,4]).to eq(Daru::Index.new([:one, :two, :four, :five]))
+      expect(@mixed_id[0,5,3,2]).to eq(Daru::Index.new(['a', 8, :d, 'c']))
     end
 
     it "returns correct index position for non-numeric index" do
@@ -102,7 +112,7 @@ describe Daru::Index do
     end
 
     it "returns correct index position for mixed index" do
-      expect(@mixed_id[0]).to eq(5)
+      expect(@mixed_id[8]).to eq(5)
       expect(@mixed_id['c']).to eq(2)
     end
   end
@@ -204,6 +214,14 @@ describe Daru::MultiIndex do
       ]))
     end
 
+    it "raises error when specifying invalid index" do
+      expect { @multi_mi[:a, :three] }.to raise_error IndexError
+      expect { @multi_mi[:a, :one, :xyz] }.to raise_error IndexError
+      expect { @multi_mi[:x] }.to raise_error IndexError
+      expect { @multi_mi[:x, :one] }.to raise_error IndexError
+      expect { @multi_mi[:x, :one, :bar] }.to raise_error IndexError
+    end
+
     it "works with numerical first levels" do
       mi = Daru::MultiIndex.from_tuples([
         [2000, 'M'],

data/spec/io/io_spec.rb

@@ -4,7 +4,7 @@ describe Daru::IO do
   describe Daru::DataFrame do
     context ".from_csv" do
       it "loads from a CSV file" do
-        df = Daru::DataFrame.from_csv('spec/fixtures/matrix_test.csv', 
+        df = Daru::DataFrame.from_csv('spec/fixtures/matrix_test.csv',
           col_sep: ' ', headers: true)
 
         df.vectors = [:image_resolution, :mls, :true_transform].to_index
@@ -15,7 +15,7 @@ describe Daru::IO do
 
       it "works properly for repeated headers" do
         df = Daru::DataFrame.from_csv('spec/fixtures/repeated_fields.csv',header_converters: :symbol)
-        expect(df.vectors.to_a).to eq(['a1', 'age_1', 'age_2', 'city', 'id', 'name_1', 'name_2'])
+        expect(df.vectors.to_a).to eq(["id", "name_1", "age_1", "city", "a1", "name_2", "age_2"])
 
         age = Daru::Vector.new([3, 4, 5, 6, nil, 8])
         expect(df['age_2']).to eq(age)
@@ -29,20 +29,41 @@ describe Daru::IO do
           expect(y_ds).to be_within(0.001).of(y_expected)
         end
       end
+      
+      it "follows the order of columns given in CSV" do
+        df = Daru::DataFrame.from_csv 'spec/fixtures/sales-funnel.csv'
+        expect(df.vectors.to_a).to eq(%W[Account Name Rep Manager Product Quantity Price Status])
+      end
     end
 
     context "#write_csv" do
-      it "writes DataFrame to a CSV file" do
-        df = Daru::DataFrame.new({
-          'a' => [1,2,3,4,5], 
+      before do
+        @df = Daru::DataFrame.new({
+          'a' => [1,2,3,4,5],
           'b' => [11,22,33,44,55],
           'c' => ['a', 'g', 4, 5,'addadf'],
           'd' => [nil, 23, 4,'a','ff']})
-        t = Tempfile.new('data.csv')
-        df.write_csv t.path
+        @tempfile = Tempfile.new('data.csv')
 
-        expect(Daru::DataFrame.from_csv(t.path)).to eq(df)
       end
+
+      it "writes DataFrame to a CSV file" do
+        @df.write_csv @tempfile.path
+        expect(Daru::DataFrame.from_csv(@tempfile.path)).to eq(@df)
+      end
+
+      it "will write headers unless headers=false" do
+        @df.write_csv @tempfile.path
+        first_line = File.open(@tempfile.path, &:readline).chomp.split(',', -1)
+        expect(first_line).to eq @df.vectors.to_a
+      end
+
+      it "will not write headers when headers=false" do
+        @df.write_csv @tempfile.path, { headers: false }
+        first_line = File.open(@tempfile.path, &:readline).chomp.split(',', -1)
+        expect(first_line).to eq @df.head(1).map { |v| (v.first || '').to_s }
+      end
+
     end
 
     context ".from_excel" do
@@ -52,8 +73,8 @@ describe Daru::IO do
         age  = Daru::Vector.new( [20, 23, 25, nil, 5.5, nil])
         city = Daru::Vector.new(['New York', 'London', 'London', 'Paris', 'Tome', nil])
         a1   = Daru::Vector.new(['a,b', 'b,c', 'a', nil, 'a,b,c', nil])
-        @expected = Daru::DataFrame.new({ 
-          :id => id, :name => name, :age => age, :city => city, :a1 => a1 
+        @expected = Daru::DataFrame.new({
+          :id => id, :name => name, :age => age, :city => city, :a1 => a1
           }, order: [:id, :name, :age, :city, :a1])
       end
 
@@ -190,8 +211,8 @@ describe Daru::IO do
         df   = Daru::DataFrame.new JSON.parse(json)
 
         expect(df.vectors).to eq([
-          'name', 'nativeName', 'tld', 'cca2', 'ccn3', 'cca3', 'currency', 'callingCode', 
-          'capital', 'altSpellings', 'relevance', 'region', 'subregion', 'language', 
+          'name', 'nativeName', 'tld', 'cca2', 'ccn3', 'cca3', 'currency', 'callingCode',
+          'capital', 'altSpellings', 'relevance', 'region', 'subregion', 'language',
           'languageCodes', 'translations', 'latlng', 'demonym', 'borders', 'area'].to_index)
 
         expect(df.row[0]['name']).to eq("Afghanistan")
@@ -208,9 +229,9 @@ describe Daru::IO do
 
     context "#save" do
       before do
-        @data_frame = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
-          c: [11,22,33,44,55]}, 
-          order: [:a, :b, :c], 
+        @data_frame = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+          c: [11,22,33,44,55]},
+          order: [:a, :b, :c],
           index: [:one, :two, :three, :four, :five])
       end
 
@@ -235,7 +256,7 @@ describe Daru::IO do
       ALL_DTYPES.each do |dtype|
         it "saves to a file and returns the same Vector of type #{dtype}" do
           vector = Daru::Vector.new(
-              [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99], 
+              [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99],
               dtype: dtype)
           outfile = Tempfile.new('vector.vec')
           vector.save(outfile.path)

data/spec/math/statistics/dataframe_spec.rb

@@ -24,28 +24,40 @@ describe Daru::DataFrame do
     end
   end
 
+  context "#variance_sample" do
+    it "calculates variance of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.variance_sample).to eq(Daru::Vector.new([4.0, 16.0, 400.0], index: [:d, :e, :f]))
+    end
+  end
+
   context "#std" do
-    it "calculates standard deviation of single leavel numeric only vectors and returns values in a Vector" do
+    it "calculates standard deviation of single level numeric only vectors and returns values in a Vector" do
       expect(@df.std).to eq(Daru::Vector.new([2, 4, 20], index: [:d, :e, :f]))
     end
   end
 
   context "#sum" do
     it "calculates sum of single level numeric only vectors and returns values in a Vector" do
-      # TODO - write tests
+      expect(@df.sum).to eq(Daru::Vector.new([33, 66, 330], index: [:d, :e, :f]))
     end
   end
 
   context "#count" do
-    # TODO
+    it "counts number of non-nil single level numeric only vectors and returns values in a Vector" do
+      expect(@df.count).to eq(Daru::Vector.new([9, 9, 9], index: [:d, :e, :f]))
+    end
   end
 
   context "#mode" do
-    # TODO
+    it "calculates mode of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.mode).to eq(Daru::Vector.new([2, 4, 20], index: [:d, :e, :f]))
+    end
   end
 
   context "#median" do
-    # TODO
+    it "calculates median of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.median).to eq(Daru::Vector.new([3, 6, 30], index: [:d, :e, :f]))
+    end
   end
 
   context "#max" do
@@ -61,11 +73,21 @@ describe Daru::DataFrame do
   end
 
   context "#min" do
-    # TODO
+    it "calculates mininum of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.min).to eq(Daru::Vector.new([1, 2, 10], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#range" do
+    it "calculates range of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.range).to eq(Daru::Vector.new([6, 12, 60], index: [:d, :e, :f]))
+    end
   end
 
   context "#product" do
-    # TODO
+    it "calculates product of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.product).to eq(Daru::Vector.new([30240, 15482880, 30240000000000], index: [:d, :e, :f]))
+    end
   end
 
   context "#describe" do
@@ -79,6 +101,16 @@ describe Daru::DataFrame do
     end
   end
 
+  context "percent_change" do
+    it "calculates percent change of numeric vectors" do
+      expect(@df.percent_change.round(2)).to eq(Daru::DataFrame.new({
+        d: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17],
+        e: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17],
+        f: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17] }
+      ))
+    end
+  end
+
   context "#cov" do
     it "calculates the variance covariance of the numeric vectors of DataFrame" do
       expect(@df.cov).to eq(Daru::DataFrame.new({
@@ -145,4 +177,4 @@ describe Daru::DataFrame do
       @df.standardize
     end
   end
-end
+end

data/spec/math/statistics/vector_spec.rb

@@ -6,12 +6,15 @@ describe Daru::Vector do
       before do
         @dv = Daru::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2], dtype: dtype
         @dv_with_nils = Daru::Vector.new [323, 11, 555, nil, 666, 234, 21, 666, 343, nil, 1, 2]
+        @dv_with_missing = Daru::Vector.new [1, 2, 3, 3], missing_values: [3], dtype: dtype
+        @dv_with_all_missing = Daru::Vector.new [3, 3], missing_values: [3], dtype: dtype
       end
 
       context "#mean" do
         it "calculates mean" do
           expect(@dv.mean).to eq(282.2)
-          expect(@dv_with_nils.mean).to eq(282.2)
+          expect(@dv_with_missing.mean).to eq(1.5)
+          expect(@dv_with_all_missing.mean).to eq(nil)
         end
       end
 
@@ -46,6 +49,22 @@ describe Daru::Vector do
         end
       end
 
+      context "#covariance_sample" do
+        it "calculates sample covariance" do
+          @dv_1 = Daru::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2]
+          @dv_2 = Daru::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 = Daru::Vector.new [323, 11, 555, 666, 234, 21, 666, 343, 1, 2]
+          @dv_2 = Daru::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)
@@ -60,20 +79,44 @@ describe Daru::Vector do
 
       context "#max" do
         it "returns the max value" do
-          @dv.max
+          expect(@dv.max).to eq(666)
         end
+        
+        it "returns the max value without considering values set as missing" do
+          expect(@dv_with_missing.max).to eq(2)
+        end
+        
+        it "returns nil when all values are set missing" do
+          expect(@dv_with_all_missing.max).to eq(nil)
+        end          
       end
 
       context "#min" do
         it "returns the min value" do
-          @dv.min
+          expect(@dv.min).to eq(1)
+        end
+        
+        it "returns the min value without considering values set as missing" do
+          expect(@dv_with_missing.min).to eq(1)
         end
+        
+        it "returns nil when all values are set missing" do
+          expect(@dv_with_all_missing.min).to eq(nil)
+        end          
       end 
 
       context "#sum" do
         it "returns the sum" do
-          @dv.sum
+          expect(@dv.sum).to eq(2822)
+        end
+        
+        it "returns the sum without considering values set as missing" do
+          expect(@dv_with_missing.sum).to eq(3)
         end
+        
+        it "returns nil when all values are set missing" do
+          expect(@dv_with_all_missing.sum).to eq(nil)
+        end        
       end
 
       context "#product" do
@@ -81,6 +124,14 @@ describe Daru::Vector do
           v = Daru::Vector.new [1, 2, 3, 4, 5], dtype: dtype
           expect(v.product).to eq(120)
         end
+
+        it "returns the product without considering values set as missing" do
+          expect(@dv_with_missing.product).to eq(2)
+        end
+        
+        it "returns nil when all values are set missing" do
+          expect(@dv_with_all_missing.product).to eq(nil)
+        end
       end
 
       context "#median" do
@@ -91,7 +142,17 @@ describe Daru::Vector do
 
       context "#mode" do
         it "returns the mode" do
-          @dv.mode
+          mode_test_example = Daru::Vector.new [1,2,3,2,4,4,4,4], dtype: dtype
+          expect(mode_test_example.mode).to eq(4)
+        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(Daru::Vector.new([10.00, 282.20, 274.08, 1.00, 666.00],
+            index: [:count, :mean, :std, :min, :max], 
+            name:  :statistics
+          ))
         end
       end
 
@@ -373,6 +434,20 @@ describe Daru::Vector do
       expect(acf[3]).to be_within(0.001) .of(0.486)
     end
   end
+  
+  context "#percent_change" do
+    it "calculates percent change" do
+      vector = Daru::Vector.new([4,6,6,8,10],index: ['a','f','t','i','k'])
+      expect(vector.percent_change).to eq(
+      Daru::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 = Daru::Vector.new([nil,6,nil,8,10],index: ['a','f','t','i','k'])
+      expect(vector2.percent_change).to eq(
+      Daru::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
@@ -463,12 +538,12 @@ describe Daru::Vector do
       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 lookback period
+      # test with a different loopback period
       ema5 = @shares.ema 5
 
-      expect(ema5[-1]) .to be_within( 0.0001).of(16.71299)
-      expect(ema5[-10]).to be_within( 0.0001).of(17.49079)
-      expect(ema5[-15]).to be_within( 0.0001).of(17.70067)
+      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
@@ -479,6 +554,56 @@ describe Daru::Vector do
     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
+
   context "#macd" do
     it "calculates moving average convergence divergence" do
       # MACD uses a lot more data than the other ones, so we need a bigger vector
@@ -506,4 +631,4 @@ describe Daru::Vector do
         Daru::Vector.new([1,3,6,10,15,21,28,36,45,55]))
     end
   end
-end 
+end