daru 0.1.2 → 0.1.3

data/spec/monkeys_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper.rb'
 describe "Monkeys" do
   context Array do
     it "#recode_repeated" do
-      expect([1,1,'a','a','b',:c,2].recode_repeated).to eq(
-        ['1_1', '1_2','a_1','a_2','b',:c,2])
+      expect([1,'a',1,'a','b',:c,2].recode_repeated).to eq(
+        ['1_1','a_1', '1_2','a_2','b',:c,2])
     end
   end
 
@@ -16,4 +16,4 @@ describe "Monkeys" do
       expect(left.elementwise_division(right)).to eq(Matrix[[1,1,1],[1,1,1],[1,1,1]])
     end
   end
-end
+end

data/spec/vector_spec.rb

@@ -83,6 +83,13 @@ describe Daru::Vector do
           expect(dv.to_a).to eq([1,2,3,4])
           expect(dv.index.to_a).to eq(['a', 'b', :r, 0])
         end
+
+        it "accepts a metadata attribute" do
+          dv = Daru::Vector.new [1,2,3,4,5], metadata: { cdc_type: 2 }
+
+          expect(dv.metadata) .to eq({ cdc_type: 2 })
+        end
+
       end
 
       context ".new_with_size" do
@@ -122,7 +129,7 @@ describe Daru::Vector do
       context "#[]" do
         context Daru::Index do
           before :each do
-            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga,
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, metadata: { cdc_type: 2 },
               index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
           end
 
@@ -161,6 +168,15 @@ describe Daru::Vector do
             expect(v[1]).to eq(3)
             expect(v[0]).to eq(1)
           end
+
+          it "raises exception for invalid index" do
+            expect { @dv[:foo] }.to raise_error(IndexError)
+            expect { @dv[:obi, :foo] }.to raise_error(IndexError)
+          end
+
+          it "retains the original vector metadata" do
+            expect(@dv[:yoda, :anakin].metadata).to eq({ cdc_type: 2 })
+          end
         end
 
         context Daru::MultiIndex do
@@ -177,11 +193,12 @@ describe Daru::Vector do
               [:c,:one,:bar],
               [:c,:one,:baz],
               [:c,:two,:foo],
-              [:c,:two,:bar]
+              [:c,:two,:bar],
+              [:d,:one,:foo]
             ]
             @multi_index = Daru::MultiIndex.from_tuples(@tuples)
             @vector = Daru::Vector.new(
-              Array.new(12) { |i| i }, index: @multi_index,
+              Array.new(13) { |i| i }, index: @multi_index,
               dtype: dtype, name: :mi_vector)
           end
 
@@ -211,6 +228,12 @@ describe Daru::Vector do
               dtype: dtype, name: :sub_sub_vector))
           end
 
+          it "returns sub vector not a single element when passed the partial tuple" do
+            mi = Daru::MultiIndex.from_tuples([[:foo]])
+            expect(@vector[:d, :one]).to eq(Daru::Vector.new([12], index: mi,
+              dtype: dtype, name: :sub_sub_vector))
+          end
+
           it "returns a vector with corresponding MultiIndex when specified numeric Range" do
             mi = Daru::MultiIndex.from_tuples([
               [:a,:two,:baz],
@@ -224,6 +247,12 @@ describe Daru::Vector do
             expect(@vector[3..9]).to eq(Daru::Vector.new([3,4,5,6,7,8,9], index: mi,
               dtype: dtype, name: :slice))
           end
+
+          it "raises exception for invalid index" do
+            expect { @vector[:foo] }.to raise_error(IndexError)
+            expect { @vector[:a, :two, :foo] }.to raise_error(IndexError)
+            expect { @vector[:x, :one] }.to raise_error(IndexError)
+          end
         end
       end
 
@@ -417,13 +446,13 @@ describe Daru::Vector do
         end
       end
 
-      context "#to_hash" do
+      context "#to_h" do
         context Daru::Index do
           it "returns the vector as a hash" do
             dv = Daru::Vector.new [1,2,3,4,5], name: :a,
               index: [:one, :two, :three, :four, :five], dtype: dtype
 
-            expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+            expect(dv.to_h).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
           end
         end
 
@@ -438,7 +467,7 @@ describe Daru::Vector do
           #     [:b,:two,:bar]
           #   ])
           #   vector = Daru::Vector.new([1,2,3,4], index: mi, dtype: dtype)
-          #   expect(vector.to_hash).to eq({
+          #   expect(vector.to_h).to eq({
           #     [:a,:two,:bar] => 1,
           #     [:a,:two,:baz] => 2,
           #     [:b,:one,:bar] => 3,
@@ -449,8 +478,15 @@ describe Daru::Vector do
       end
 
       context "#uniq" do
+        before do
+          @v = Daru::Vector.new [1, 2, 2, 2.0, 3, 3.0], index:[:a, :b, :c, :d, :e, :f], metadata: { cdc_type: 2 }
+        end
         it "keeps only unique values" do
-          # TODO: fill this in
+          expect(@v.uniq).to eq(Daru::Vector.new [1, 2, 2.0, 3, 3.0], index: [:a, :b, :d, :e, :f])
+        end
+
+        it "retains the original vector metadata" do
+          expect(@v.uniq.metadata).to eq({ cdc_type: 2 })
         end
       end
 
@@ -467,7 +503,7 @@ describe Daru::Vector do
       context "#sort" do
         context Daru::Index do
           before do
-            @dv = Daru::Vector.new [33,2,15,332,1], name: :dv, index: [:a, :b, :c, :d, :e]
+            @dv = Daru::Vector.new [33,2,15,332,1], name: :dv, index: [:a, :b, :c, :d, :e], metadata: { cdc_type: 2 }
           end
 
           it "sorts the vector with defaults and returns a new vector, preserving indexing" do
@@ -485,11 +521,36 @@ describe Daru::Vector do
             expect(sorted).to eq(Daru::Vector.new(["My", "Jazz", "Guitar", "My Jazz Guitar"], index: [2,1,3,0]))
           end
 
-          it "places nils near the beginning of the vector" do
+          it "places nils near the beginning of the vector when sorting ascendingly" do
             with_nils = Daru::Vector.new [22,4,nil,111,nil,2]
 
             expect(with_nils.sort).to eq(Daru::Vector.new([nil,nil,2,4,22,111], index: [2,4,5,1,0,3]))
           end if dtype == :array
+
+          it "places nils near the beginning of the vector when sorting descendingly" do
+            with_nils = Daru::Vector.new [22,4,nil,111,nil,2]
+
+            expect(with_nils.sort(ascending: false)).to eq(
+              Daru::Vector.new [nil,nil,111,22,4,2], index: [4,2,3,0,1,5])
+          end
+
+          it "correctly sorts vector in ascending order with non-numeric data and nils" do
+            non_numeric = Daru::Vector.new ['a','b', nil, 'aa', '1234', nil]
+
+            expect(non_numeric.sort(ascending: true)).to eq(
+              Daru::Vector.new [nil,nil,'1234','a','aa','b'], index: [2,5,4,0,3,1])
+          end
+
+          it "correctly sorts vector in descending order with non-numeric data and nils" do
+            non_numeric = Daru::Vector.new ['a','b', nil, 'aa', '1234', nil]
+
+            expect(non_numeric.sort(ascending: false)).to eq(
+              Daru::Vector.new [nil,nil,'b','aa','a','1234'], index: [5,2,1,3,0,4])
+          end
+
+          it "retains the original vector metadata" do
+            expect(@dv.sort.metadata).to eq({ cdc_type: 2 })
+          end
         end
 
         context Daru::MultiIndex do
@@ -552,7 +613,7 @@ describe Daru::Vector do
           index  = Daru::DateTimeIndex.date_range(:start => '2012', :periods => 5)
           @vector.index = index
 
-          expect(@vector.index.class).to eq(DateTimeIndex)
+          expect(@vector.index.class).to eq(Daru::DateTimeIndex)
           expect(@vector['2012-1-1']).to eq(1)
         end
 
@@ -564,12 +625,50 @@ describe Daru::Vector do
       end
 
       context "#reindex" do
+        before do
+          @vector = Daru::Vector.new([1,2,3,4,5], metadata: { cdc_type: 2 })
+          @index = Daru::Index.new([3,4,1,0,6])
+        end
         it "intelligently reindexes" do
-          vector = Daru::Vector.new([1,2,3,4,5])
-          index = Daru::Index.new([3,4,1,0,6])
+          expect(@vector.reindex(@index)).to eq(
+            Daru::Vector.new([4,5,2,1,nil], index: @index))
+        end
+        it "retains the original vector metadata" do
+          expect(@vector.reindex(@index).metadata).to eq({ cdc_type: 2 })
+        end
+      end
 
-          expect(vector.reindex(index)).to eq(
-            Daru::Vector.new([4,5,2,1,nil], index: index))
+      context "#dup" do
+        before do
+          @dv = Daru::Vector.new [1,2], name: :yoda, metadata: { cdc_type: 2 }, index: [:happy, :lightsaber]
+        end
+
+        it "copies the original data" do
+          expect(@dv.dup.send(:data)).to eq([1,2])
+        end
+
+        it "creates a new data object" do
+          expect(@dv.dup.send(:data).object_id).not_to eq(@dv.send(:data).object_id)
+        end
+
+        it "copies the name" do
+          expect(@dv.dup.name).to eq(:yoda)
+        end
+
+        it "copies the original vector metadata" do
+          expect(@dv.dup.metadata).to eq({ cdc_type: 2 })
+        end
+
+        it "creates a new metadata object" do
+          expect(@dv.dup.metadata.object_id).not_to eq(@dv.metadata.object_id)
+        end
+
+        it "copies the original index" do
+          expect(@dv.dup.index).to eq(Daru::Index.new([:happy, :lightsaber]))
+        end
+
+        it "creates a new index object" do
+          expect(@dv.dup.index.object_id).not_to eq(@dv.index.object_id)
         end
       end
 
@@ -740,9 +839,16 @@ describe Daru::Vector do
 
   context "#clone_structure" do
     context Daru::Index do
+      before do
+        @vec = Daru::Vector.new([1,2,3,4,5], metadata: { cdc_type: 2 }, index: [:a,:b,:c,:d,:e])
+      end
+
       it "clones a vector with its index and fills it with nils" do
-        vec = Daru::Vector.new([1,2,3,4,5], index: [:a,:b,:c,:d,:e])
-        expect(vec.clone_structure).to eq(Daru::Vector.new([nil,nil,nil,nil,nil], index: [:a,:b,:c,:d,:e]))
+        expect(@vec.clone_structure).to eq(Daru::Vector.new([nil,nil,nil,nil,nil], index: [:a,:b,:c,:d,:e]))
+      end
+
+      it "retains the original vector metadata" do
+        expect(@vec.clone_structure.metadata).to eq({ cdc_type: 2 })
       end
     end
 
@@ -864,11 +970,22 @@ describe Daru::Vector do
   end
 
   context "#only_valid" do
-    it "returns a Vector of only non-nil data" do
-      vector = Daru::Vector.new [1,2,3,4,nil,3,nil],
-        index: [:a, :b, :c, :d, :e, :f, :g]
-      expect(vector.only_valid).to eq(Daru::Vector.new([1,2,3,4,3],
-        index: [:a, :b, :c, :d, :f]))
+    [:array, :gsl].each do |dtype|
+      describe dtype do
+        before do
+          @vector = Daru::Vector.new [1,2,3,4,5,3,5], metadata: { cdc_type: 2 },
+            index: [:a, :b, :c, :d, :e, :f, :g], dtype: dtype, missing_values: [3, 5]
+        end
+
+        it "returns a Vector of only non-missing data" do
+          expect(@vector.only_valid).to eq(Daru::Vector.new([1,2,4],
+            index: [:a, :b, :d], dtype: dtype))
+        end
+
+        it "retains the original vector metadata" do
+          expect(@vector.only_valid.metadata).to eq({ cdc_type: 2 })
+        end
+      end
     end
   end
 
@@ -1022,19 +1139,34 @@ describe Daru::Vector do
   end
 
   context "#lag" do
+    before do
+      @xiu = Daru::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], metadata: { cdc_type: 2 })
+    end
+
     it "lags the vector by specified amount" do
-      xiu = Daru::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])
-      lag1 = xiu.lag
+      lag1 = @xiu.lag
 
       expect(lag1[lag1.size - 1]).to be_within(0.001).of(16.66)
       expect(lag1[lag1.size - 2]).to be_within(0.001).of(16.36)
 
       #test with different lagging unit
-      lag2 = xiu.lag(2)
+      lag2 = @xiu.lag(2)
 
       expect(lag2[lag2.size - 1]).to be_within(0.001).of(16.36)
       expect(lag2[lag2.size - 2]).to be_within(0.001).of(16.56)
     end
+
+    it "retains the original vector metadata" do
+      expect(@xiu.lag(1).metadata).to eq({ cdc_type: 2 })
+    end
   end
+
+  context "#metadata" do
+    it "defaults to an empty hash for metadata" do
+      dv = Daru::Vector.new [1,2,3,4,5]
+      expect(dv.metadata).to eq({})
+    end
+  end
+
 end if mri?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daru
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-17 00:00:00.000000000 Z
+date: 2016-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reportbuilder
@@ -192,20 +192,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
-- !ruby/object:Gem::Dependency
-  name: bloomfilter-rb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: dbd-sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -262,6 +248,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.40.0
 description: |
   Daru (Data Analysis in RUby) is a library for analysis, manipulation and visualization
   of data. Daru works seamlessly accross interpreters and leverages interpreter-specific
@@ -277,6 +277,8 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".travis.yml"
 - CONTRIBUTING.md
 - Gemfile
@@ -286,10 +288,13 @@ files:
 - Rakefile
 - benchmarks/TradeoffData.csv
 - benchmarks/dataframe_creation.rb
+- benchmarks/duplicating.rb
 - benchmarks/group_by.rb
+- benchmarks/joining.rb
 - benchmarks/row_access.rb
 - benchmarks/row_assign.rb
 - benchmarks/sorting.rb
+- benchmarks/statistics.rb
 - benchmarks/vector_access.rb
 - benchmarks/vector_assign.rb
 - benchmarks/where_clause.rb
@@ -368,11 +373,26 @@ homepage: http://github.com/v0dro/daru
 licenses:
 - BSD-2
 metadata: {}
-post_install_message: "*************************************************************************\nThank
-  you for installing daru!\n\n  oOOOOOo \n ,|    oO\n//|     |\n\\\\|     |\n `|     |\n
-  \ `-----`\n\n\nHope you love daru! For enhanced interactivity and better visualizations,
-  \nconsider using gnuplotrb and nyaplot with iruby. For statistics use the \nstatsample
-  family.\n\nRead the README for interesting use cases and examples.\n\nCheers!\n*************************************************************************\n"
+post_install_message: |
+  *************************************************************************
+  Thank you for installing daru!
+
+    oOOOOOo
+   ,|    oO
+  //|     |
+  \\|     |
+   `|     |
+    `-----`
+
+
+  Hope you love daru! For enhanced interactivity and better visualizations,
+  consider using gnuplotrb and nyaplot with iruby. For statistics use the
+  statsample family.
+
+  Read the README for interesting use cases and examples.
+
+  Cheers!
+  *************************************************************************
 rdoc_options: []
 require_paths:
 - lib