daru 0.0.2.3 → 0.0.3

data/spec/index_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper.rb'
+
+describe Daru::Index do
+  context "#initialize" do
+    it "creates an Index from Array" do
+      idx = Daru::Index.new ['speaker', 'mic', 'guitar', 'amp']
+
+      expect(idx.to_a).to eq([:speaker, :mic, :guitar, :amp])
+    end
+  end
+
+  context "#size" do
+    it "correctly returns the size of the index" do
+      idx = Daru::Index.new ['speaker', 'mic', 'guitar', 'amp']
+
+      expect(idx.size).to eq(4)
+    end
+  end
+
+  context "#re_index" do
+    before :each do
+      @old = Daru::Index.new [:bob, :fisher, :zakir]
+    end
+    it "returns a new index object" do
+      n   = @old.re_index(@old + [:john, :shrinivas]) 
+
+      expect(n.object_id).not_to eq(@old.object_id)
+      expect(n.to_a).to eq([:bob, :fisher, :zakir, :john, :shrinivas])
+    end
+
+    it "does not over-ride existing indexes" do
+      n = @old.re_index(@old + :bob)
+
+      expect(n.object_id).not_to eq(@old.object_id)
+      expect(n.to_a)     .to eq([:bob, :fisher, :zakir])
+    end
+  end
+
+  context "#+" do
+    before :each do
+      @left = Daru::Index.new [:miles, :geddy, :eric]
+      @right = Daru::Index.new [:bob, :jimi, :richie]
+    end
+
+    it "adds 2 indexes and returns an Index" do
+      expect(@left + @right).to eq([:miles, :geddy, :eric, :bob, :jimi, :richie].to_index)
+    end
+
+    it "adds an Index and an Array to return an Index" do
+      expect(@left + [:bob, :jimi, :richie]).to eq([:miles, :geddy, :eric, 
+        :bob, :jimi, :richie].to_index)
+    end
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper.rb'
+
+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', 
+        col_sep: ' ', headers: true) do |csv|
+        csv.convert do |field, info|
+          case info[:header]
+          when :true_transform
+            field.split(',').map { |s| s.to_f }
+          else
+            field
+          end
+        end
+      end
+
+      expect(df.vectors).to eq([:image_resolution, :true_transform, :mls].to_index)
+      expect(df.vector[:image_resolution].first).to eq(6.55779)
+      expect(df.vector[:true_transform].first[15]).to eq(1.0)
+    end
+  end
+
+  context "JSON" do
+    it "loads parsed JSON" do
+      require 'json'
+
+      json = File.read 'spec/fixtures/countries.json'
+      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, 
+        :languageCodes, :translations, :latlng, :demonym, :borders, :area].to_index)
+
+      expect(df.row[0][:name]).to eq("Afghanistan")
+    end
+  end
+
+  context "#inspect" do
+    it "prints DataFrame pretty" do
+
+    end
+  end
+
+  context "#to_csv" do
+    # TODO
+  end
+end

data/spec/monkeys_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper.rb'
+
+describe "Monkeys" do
+  context "Array" do
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,15 @@
 require 'rspec'
+require 'awesome_print'
 
-if RUBY_ENGINE == 'jruby'
+def mri?
+  RUBY_ENGINE == 'ruby'
+end
+
+def jruby?
+  RUBY_ENGINE == 'jruby'
+end
+
+if jruby?
   require 'mdarray'
 else
   require 'nmatrix'

data/spec/vector_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper.rb'
+
+describe Daru::Vector do
+  context "#initialize" do
+    it "initializes from an Array" do
+      dv = Daru::Vector.new :ravan, [1,2,3,4,5], [:ek, :don, :teen, :char, :pach]
+
+      expect(dv.name) .to eq(:ravan)
+      expect(dv.index).to eq(Daru::Index.new [:ek, :don, :teen, :char, :pach])
+    end
+
+    it "accepts Index object" do
+      idx = Daru::Index.new [:yoda, :anakin, :obi, :padme, :r2d2]
+
+      dv = Daru::Vector.new :yoga, [1,2,3,4,5], idx
+
+      expect(dv.name) .to eq(:yoga)
+      expect(dv.index).to eq(idx)
+    end
+
+    it "raises error for improper Index" do
+      expect {
+        dv = Daru::Vector.new :yoga, [1,2,3,4,5], [:i, :j, :k]
+      }.to raise_error
+
+      expect {
+        idx = Daru::Index.new [:i, :j, :k]
+        dv  = Daru::Vector.new :yoga, [1,2,3,4,5], idx 
+      }.to raise_error
+    end
+
+    it "initializes without specifying an index" do
+      dv = Daru::Vector.new :vishnu, [1,2,3,4,5]
+
+      expect(dv.index).to eq(Daru::Index.new [0,1,2,3,4])
+    end
+
+    it "inserts nils for extra indices" do
+      dv = Daru::Vector.new :yoga, [1,2,3], [0,1,2,3,4]
+
+      expect(dv).to eq([1,2,3,nil,nil].dv(:yoga))
+    end
+  end
+
+  context "#[]" do
+    before :each do
+      @dv = Daru::Vector.new :yoga, [1,2,3,4,5], [:yoda, :anakin, :obi, :padme, :r2d2]
+    end
+
+    it "returns an element after passing an index" do
+      expect(@dv[:yoda]).to eq(1)
+    end
+
+    it "returns an element after passing a numeric index" , :focus => true do
+      expect(@dv[0]).to eq(1)
+    end
+
+    it "returns a vector with given indices for multiple indices" do
+      expect(@dv[:yoda, :anakin]).to eq(Daru::Vector.new(:yoga, [1,2], 
+        [:yoda, :anakin]))
+    end
+  end
+
+  context "#[]=" do
+    before :each do
+      @dv = Daru::Vector.new :yoga, [1,2,3,4,5], [:yoda, :anakin, :obi, :padme, :r2d2]
+    end
+
+    it "assigns at the specified index" do
+      @dv[:yoda] = 666
+
+      expect(@dv[:yoda]).to eq(666)
+    end
+
+    it "assigns at the specified Integer index" do
+      @dv[0] = 666
+
+      expect(@dv[:yoda]).to eq(666)
+    end
+  end
+
+  context "#concat" do
+    before :each do
+      @dv = Daru::Vector.new :yoga, [1,2,3,4,5], [:warwick, :thompson, :jackson, :fender, :esp]
+    end
+
+    it "concatenates a new element at the end of vector with index" do
+      @dv.concat 6, :ibanez
+
+      expect(@dv.index)   .to eq(
+        [:warwick, :thompson, :jackson, :fender, :esp, :ibanez].to_index)
+      expect(@dv[:ibanez]).to eq(6)
+      expect(@dv[5])      .to eq(6)
+    end
+
+    it "concatenates without index if index is default numeric" do
+      vector = Daru::Vector.new :nums, [1,2,3,4,5]
+
+      vector.concat 6
+
+      expect(vector.index).to eq([0,1,2,3,4,5].to_index)
+      expect(vector[5])   .to eq(6)
+    end
+
+    it "raises error if index not specified and non-numeric index" do
+      expect {
+        @dv.concat 6
+      }.to raise_error
+    end
+  end
+
+  context "#delete" do
+    it "deletes specified value in the vector" do
+      dv = Daru::Vector.new :a, [1,2,3,4,5]
+
+      dv.delete 3
+
+      expect(dv).to eq(Daru::Vector.new :a, [1,2,4,5])
+    end
+  end
+
+  context "#delete_at" do
+    before :each do
+      @dv = Daru::Vector.new :a, [1,2,3,4,5], [:one, :two, :three, :four, :five]
+    end
+
+    it "deletes element of specified index" do
+      @dv.delete_at :one
+
+      expect(@dv).to eq(Daru::Vector.new :a, [2,3,4,5], [:two, :three, :four, :five])
+    end
+
+    it "deletes element of specified integer index" do
+      @dv.delete_at 2
+
+      expect(@dv).to eq(Daru::Vector.new :a, [1,2,4,5], [:one, :two, :four, :five])
+    end
+  end
+
+  context "#index_of" do
+    it "returns index of specified value" do
+      dv = Daru::Vector.new :a, [1,2,3,4,5], [:one, :two, :three, :four, :five]
+
+      expect(dv.index_of(1)).to eq(:one)
+    end
+  end
+
+  context "#to_hash" do
+    it "returns the vector as a hash" do
+      dv = Daru::Vector.new :a, [1,2,3,4,5], [:one, :two, :three, :four, :five]
+
+      expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+    end
+  end
+end if mri?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daru
 version: !ruby/object:Gem::Version
-  version: 0.0.2.3
+  version: 0.0.3
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-14 00:00:00.000000000 Z
+date: 2014-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !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
@@ -38,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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: nmatrix
   requirement: !ruby/object:Gem::Requirement
@@ -69,18 +97,25 @@ files:
 - History.txt
 - LICENSE
 - README.md
+- Rakefile
 - daru.gemspec
 - lib/daru.rb
 - lib/daru/dataframe.rb
+- lib/daru/dataframe_by_row.rb
+- lib/daru/dataframe_by_vector.rb
+- lib/daru/index.rb
+- lib/daru/io.rb
 - lib/daru/monkeys.rb
 - lib/daru/vector.rb
 - lib/version.rb
+- spec/dataframe_spec.rb
+- spec/fixtures/countries.json
 - spec/fixtures/matrix_test.csv
-- spec/jruby/dataframe_spec.rb
-- spec/jruby/vector_spec.rb
-- spec/mri/dataframe_spec.rb
-- spec/mri/vector_spec.rb
+- spec/index_spec.rb
+- spec/io_spec.rb
+- spec/monkeys_spec.rb
 - spec/spec_helper.rb
+- spec/vector_spec.rb
 homepage: http://github.com/v0dro/daru
 licenses:
 - BSD-2
@@ -106,9 +141,11 @@ signing_key:
 specification_version: 4
 summary: Data Analysis in RUby
 test_files:
+- spec/dataframe_spec.rb
+- spec/fixtures/countries.json
 - spec/fixtures/matrix_test.csv
-- spec/jruby/dataframe_spec.rb
-- spec/jruby/vector_spec.rb
-- spec/mri/dataframe_spec.rb
-- spec/mri/vector_spec.rb
+- spec/index_spec.rb
+- spec/io_spec.rb
+- spec/monkeys_spec.rb
 - spec/spec_helper.rb
+- spec/vector_spec.rb

data/spec/jruby/dataframe_spec.rb

@@ -1 +0,0 @@
-# Tests if interpreter is JRuby

data/spec/jruby/vector_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper.rb'
-# Tests if interpreter is JRuby
-
-describe Daru::Vector do
-  context ".initialize" do
-    it "creates a vector object with an MDArray" do
-      vector = Daru::Vector.new(MDArray.double([5], [1,2,3,4,5]), :uhura)
-
-      expect(vector[1])  .to eq(2)
-      expect(vector.name).to eq(:uhura)
-    end
-
-    it "creates a vector object with a Hash with different values" do
-      vector = Daru::Vector.new({ sulu: MDArray.double([5], [1,2,3,4,5])})
-
-      expect(vector[1])  .to eq(2)
-      expect(vector.name).to eq(:sulu) 
-    end
-  end
-end if RUBY_ENGINE == 'jruby'

data/spec/mri/dataframe_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper.rb'
-
-describe Daru::DataFrame do
-  context "DataFrame of Array" do
-    
-    before :each do
-      @df = Daru::DataFrame.new({a: Daru::Vector.new(1..3), 
-        b: (50..52).daru_vector, b_bad: ['Jesse', 'Walter', 'Hank'].daru_vector}, 
-        [:b_bad, :a, :b], :muddler)
-
-      @vector = Daru::Vector.new 1..3, :a
-    end
-
-    it "checks for the size of DataFrame" do
-      expect(@df.size).to eq(3)
-    end
-
-    it "raises exception for uneven vectors" do
-      expect do
-        df = Daru::DataFrame.new({a: (1..5).dv, b: [1,2,3].daru_vector})
-      end.to raise_error
-    end
-
-    it "returns vector by specifying as method" do
-      expect(@df.a).to eq(@vector)
-    end
-
-    it "returns vector by specifying as index" do
-      expect(@df[:a]).to eq(@vector)
-    end
-
-    it "returns vector by specifying as a column argument" do
-      expect(@df.column(:a)).to eq(@vector)
-    end
-
-    it "returns a row" do
-      r = @df.row 0
-
-      expect(r).to eq({:b_bad=> "Jesse", :a=> 1, :b=> 50})
-    end
-
-    it "iterates over columns in the specified order" do
-      cols = []
-      df = @df.each_vector do |col|
-        expect(col.is_a?(Daru::Vector)).to be(true)
-        cols << col.name
-      end
-
-      expect(cols).to eq([:b_bad, :a, :b])
-      expect(df).to eq(@df)
-    end
-
-    it "iterates over rows" do
-      @df.each_row do |row|
-        expect(row.size).to be(@df.fields.size)
-      end
-    end
-
-    it "filters rows" do
-      res = @df.filter_rows(@df.name) { |row| row[:b] == 50 }
-
-      expect(res).to eq(Daru::DataFrame.new({a: [1].dv, b: [50].dv, b_bad: ['Jesse'].dv}, 
-        @df.fields, @df.name))
-    end
-
-    it "shows column fields" do
-      expect(@df.fields).to eq([:b_bad, :a, :b])
-    end
-
-    it "inserts a new vector" do
-      @df.insert_vector :c, Daru::Vector.new([3,6,9])
-
-      expect(@df.fields.include?(:c)).to be(true)
-    end
-
-    it "inserts a new row" do
-      @df.insert_row ["Fred",6, 6]
-
-      expect(@df.a.vector)    .to eq([1,2,3,6])
-      expect(@df.b.vector)    .to eq([50,51,52,6])
-      expect(@df.b_bad.vector).to eq(['Jesse', 'Walter', 'Hank', 'Fred'])
-    end
-
-    it "raises an error for inappropriate row insertion" do
-      expect { @df.insert_row [1,1] }.to raise_error
-    end
-
-    it "deletes a vector" do
-      @df.delete :a
-
-      expect(@df.fields.include? :a).to be(false)
-    end
-
-    it "returns a DataFrame of requested fields" do
-      req = @df = Daru::DataFrame.new({a: Daru::Vector.new(1..3), 
-        b: (50..52).daru_vector}, [:a, :b], :muddler)
-
-      expect(@df[:a, :b]).to eq(req)
-    end
-
-    it "creates DataFrame from Array" do
-      a_df = Daru::DataFrame.new({a: [1,2,3,4], b: [10,11,12,13]})
-
-      expect(a_df.a.is_a? Daru::Vector).to eq(true)
-      expect(a_df.a.vector).to eq([1,2,3,4])
-    end
-  end
-
-  context "Malformed DataFrame from Array" do
-    it "adds extra nil vectors from fields" do
-      df = Daru::DataFrame.new({a: (1..4).dv, b: (50..53).dv}, [:b, :a, :jazzy, :joe])
-
-      expect(df.fields).to eq([:b, :a, :jazzy, :joe])
-      expect(df.jazzy).to eq(([nil]*4).dv(:jazzy))
-      expect(df.joe).to eq(([nil]*4).dv(:joe))
-    end
-  end
-
-  context "DataFrame from files" do
-
-    it "loads a DataFrame from CSV" do
-      df = Daru::DataFrame.from_csv('spec/fixtures/matrix_test.csv', 
-        {col_sep: ' ', headers: true}) do |csv|
-        csv.convert do |field, info|
-          case info[:header]
-          when :true_transform
-            field.split(',').map { |s| s.to_f }
-          else
-            field
-          end
-        end
-      end
-
-      expect(df.fields).to eq([:image_resolution, :true_transform, :mls])
-      expect(df[:image_resolution].first).to eq(6.55779)
-      expect(df.column(:true_transform).first[15]).to eq(1.0)
-    end
-  end
-end if RUBY_ENGINE == 'ruby'