daru_lite 0.1.1 → 0.1.3

data/spec/index/categorical_index_spec.rb

@@ -1,36 +1,47 @@
 require 'spec_helper.rb'
 
 describe DaruLite::CategoricalIndex do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { [:a, :b, :a, :a, :c] }
+
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#pos" do
     context "when the category is non-numeric" do
-      let(:idx) { described_class.new [:a, :b, :a, :a, :c] }
-
       context "single category" do
-        subject { idx.pos :a }
+        subject { index.pos :a }
 
         it { is_expected.to eq [0, 2, 3] }
       end
 
       context "multiple categories" do
-        subject { idx.pos :a, :c }
+        subject { index.pos :a, :c }
 
         it { is_expected.to eq [0, 2, 3, 4] }
       end
 
       context "invalid category" do
-        it { expect { idx.pos :e }.to raise_error IndexError }
+        it { expect { index.pos :e }.to raise_error IndexError }
       end
 
       context "positional index" do
-        it { expect(idx.pos 0).to eq 0 }
+        it { expect(index.pos 0).to eq 0 }
       end
 
       context "invalid positional index" do
-        it { expect { idx.pos 5 }.to raise_error IndexError }
+        it { expect { index.pos 5 }.to raise_error IndexError }
       end
 
       context "multiple positional indexes" do
-        subject { idx.pos 0, 1, 2 }
+        subject { index.pos 0, 1, 2 }
 
         it { is_expected.to be_a Array }
         its(:size) { is_expected.to eq 3 }
@@ -167,4 +178,12 @@ describe DaruLite::CategoricalIndex do
       it { expect(idx.valid? :a, 1, 5).to eq false }
     end
   end
+
+  describe '#delete_at' do
+    subject { index.delete_at(3) }
+
+    let(:index) { described_class.new([:a, 1, :a, 1, 'c']) }
+
+    it { is_expected.to eq(described_class.new([:a, 1, :a, 'c'])) }
+  end
 end

data/spec/index/index_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper.rb'
 
 describe DaruLite::Index do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { ['one', 'two', 'three'] }
+
   context ".new" do
     it "creates an Index object if Index-like data is supplied" do
       i = DaruLite::Index.new [:one, 'one', 1, 2, :two]
@@ -147,6 +150,16 @@ describe DaruLite::Index do
     end
   end
 
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#&" do
     before :each do
       @left = DaruLite::Index.new [:miles, :geddy, :eric]
@@ -389,6 +402,14 @@ describe DaruLite::Index do
 
   end
 
+  describe '#delete_at' do
+    subject { index.delete_at(1) }
+
+    let(:index) { described_class.new([:a, :b, 1, 2]) }
+
+    it { is_expected.to eq(described_class.new([:a, 1, 2])) }
+  end
+
   context '#to_df' do
     let(:idx) do
       DaruLite::Index.new(['speaker', 'mic', 'guitar', 'amp'],

data/spec/index/multi_index_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper.rb'
 
 describe DaruLite::MultiIndex do
-  before(:each) do
-    @index_tuples = [
-      [:a,:one,:bar],
-      [:a,:one,:baz],
-      [:a,:two,:bar],
-      [:a,:two,:baz],
-      [:b,:one,:bar],
-      [:b,:two,:bar],
-      [:b,:two,:baz],
-      [:b,:one,:foo],
-      [:c,:one,:bar],
-      [:c,:one,:baz],
-      [:c,:two,:foo],
-      [:c,:two,:bar]
+  let(:index) { described_class.from_tuples(index_tuples) }
+  let(:index_tuples) do
+    [
+      [:a, :one, :bar],
+      [:a, :one, :baz],
+      [:a, :two, :bar],
+      [:a, :two, :baz],
+      [:b, :one, :bar],
+      [:b, :two, :bar],
+      [:b, :two, :baz],
+      [:b, :one, :foo],
+      [:c, :one, :bar],
+      [:c, :one, :baz],
+      [:c, :two, :foo],
+      [:c, :two, :bar]
     ]
-    @multi_mi = DaruLite::MultiIndex.from_tuples(@index_tuples)
   end
 
   context ".initialize" do
@@ -71,16 +71,16 @@ describe DaruLite::MultiIndex do
 
       it "raises SizeError for wrong number of name" do
         error_msg = "\'names\' and \'levels\' should be of same size. Size of the \'name\' array is 2 and size of the MultiIndex \'levels\' and \'labels\' is 3.\nIf you do not want to set name for particular level (say level \'i\') then put empty string on index \'i\' of the \'name\' Array."
-        expect { @multi_mi.name = ['n1', 'n2'] }.to raise_error(SizeError, error_msg)
+        expect { index.name = ['n1', 'n2'] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 0 and size of the MultiIndex 'levels' and 'labels' is 3.\nIf you do not want to set name for particular level (say level 'i') then put empty string on index 'i' of the 'name' Array."
-        expect { @multi_mi.name = [ ] }.to raise_error(SizeError, error_msg)
+        expect { index.name = [ ] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 1 and size of the MultiIndex 'levels' and 'labels' is 3.\nIf you do not want to set name for particular level (say level 'i') then put empty string on index 'i' of the 'name' Array."
-        expect { @multi_mi.name = [''] }.to raise_error(SizeError, error_msg)
+        expect { index.name = [''] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 4 and size of the MultiIndex 'levels' and 'labels' is 3."
-        expect { @multi_mi.name = ['n1', 'n2', 'n3', 'n4'] }.to raise_error(SizeError, error_msg)
+        expect { index.name = ['n1', 'n2', 'n3', 'n4'] }.to raise_error(SizeError, error_msg)
       end
     end
   end
@@ -101,8 +101,8 @@ describe DaruLite::MultiIndex do
     end
 
     it "creates a triple layer MultiIndex from tuples" do
-      expect(@multi_mi.levels).to eq([[:a,:b,:c], [:one, :two],[:bar,:baz,:foo]])
-      expect(@multi_mi.labels).to eq([
+      expect(index.levels).to eq([[:a,:b,:c], [:one, :two],[:bar,:baz,:foo]])
+      expect(index.labels).to eq([
         [0,0,0,0,1,1,1,1,2,2,2,2],
         [0,0,1,1,0,1,1,0,0,0,1,1],
         [0,1,0,1,0,0,1,2,0,1,2,0]
@@ -132,23 +132,23 @@ describe DaruLite::MultiIndex do
 
   context "#size" do
     it "returns size of MultiIndex" do
-      expect(@multi_mi.size).to eq(12)
+      expect(index.size).to eq(12)
     end
   end
 
   context "#[]" do
     it "returns the row number when specifying the complete tuple" do
-      expect(@multi_mi[:a, :one, :baz]).to eq(1)
+      expect(index[:a, :one, :baz]).to eq(1)
     end
 
     it "returns MultiIndex when specifying incomplete tuple" do
-      expect(@multi_mi[:b]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[:b]).to eq(DaruLite::MultiIndex.from_tuples([
         [:b,:one,:bar],
         [:b,:two,:bar],
         [:b,:two,:baz],
         [:b,:one,:foo]
       ]))
-      expect(@multi_mi[:b, :one]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[:b, :one]).to eq(DaruLite::MultiIndex.from_tuples([
         [:b,:one,:bar],
         [:b,:one,:foo]
       ]))
@@ -156,7 +156,7 @@ describe DaruLite::MultiIndex do
     end
 
     it "returns MultiIndex when specifying wholly numeric ranges" do
-      expect(@multi_mi[3..6]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[3..6]).to eq(DaruLite::MultiIndex.from_tuples([
         [:a,:two,:baz],
         [:b,:one,:bar],
         [:b,:two,:bar],
@@ -165,11 +165,11 @@ describe DaruLite::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
+      expect { index[:a, :three] }.to raise_error IndexError
+      expect { index[:a, :one, :xyz] }.to raise_error IndexError
+      expect { index[:x] }.to raise_error IndexError
+      expect { index[:x, :one] }.to raise_error IndexError
+      expect { index[:x, :one, :bar] }.to raise_error IndexError
     end
 
     it "works with numerical first levels" do
@@ -189,93 +189,89 @@ describe DaruLite::MultiIndex do
     end
   end
 
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(index_tuples) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << [:d, :one, :bar] }.not_to change { index.to_a }
+    end
+  end
+
   context "#include?" do
     it "checks if a completely specified tuple exists" do
-      expect(@multi_mi.include?([:a,:one,:bar])).to eq(true)
+      expect(index.include?([:a,:one,:bar])).to eq(true)
     end
 
     it "checks if a top layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a])).to eq(true)
+      expect(index.include?([:a])).to eq(true)
     end
 
     it "checks if a middle layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a, :one])).to eq(true)
+      expect(index.include?([:a, :one])).to eq(true)
     end
 
     it "checks for non-existence of completely specified tuple" do
-      expect(@multi_mi.include?([:b, :two, :foo])).to eq(false)
+      expect(index.include?([:b, :two, :foo])).to eq(false)
     end
 
     it "checks for non-existence of a top layer incomplete tuple" do
-      expect(@multi_mi.include?([:d])).to eq(false)
+      expect(index.include?([:d])).to eq(false)
     end
 
     it "checks for non-existence of a middle layer incomplete tuple" do
-      expect(@multi_mi.include?([:c, :three])).to eq(false)
+      expect(index.include?([:c, :three])).to eq(false)
     end
   end
 
   context "#key" do
     it "returns the tuple of the specified number" do
-      expect(@multi_mi.key(3)).to eq([:a,:two,:baz])
+      expect(index.key(3)).to eq([:a,:two,:baz])
     end
 
     it "returns nil for non-existent pointer number" do
       expect {
-        @multi_mi.key(100)
+        index.key(100)
       }.to raise_error ArgumentError
     end
   end
 
   context "#to_a" do
     it "returns tuples as an Array" do
-      expect(@multi_mi.to_a).to eq(@index_tuples)
+      expect(index.to_a).to eq(index_tuples)
     end
   end
 
   context "#dup" do
     it "completely duplicates the object" do
-      duplicate = @multi_mi.dup
-      expect(duplicate)          .to eq(@multi_mi)
-      expect(duplicate.object_id).to_not eq(@multi_mi.object_id)
+      duplicate = index.dup
+      expect(duplicate)          .to eq(index)
+      expect(duplicate.object_id).to_not eq(index.object_id)
     end
   end
 
   context "#inspect" do
     context 'small index' do
-      subject {
-        DaruLite::MultiIndex.from_tuples [
-          [:a,:one,:bar],
-          [:a,:one,:baz],
-          [:a,:two,:bar],
-          [:a,:two,:baz],
-          [:b,:one,:bar],
-          [:b,:two,:bar],
-          [:b,:two,:baz],
-          [:b,:one,:foo],
-          [:c,:one,:bar],
-          [:c,:one,:baz],
-          [:c,:two,:foo],
-          [:c,:two,:bar]
-        ]
-      }
-
-      its(:inspect) { is_expected.to eq %Q{
-        |#<DaruLite::MultiIndex(12x3)>
-        |   a one bar
-        |         baz
-        |     two bar
-        |         baz
-        |   b one bar
-        |     two bar
-        |         baz
-        |     one foo
-        |   c one bar
-        |         baz
-        |     two foo
-        |         bar
+      subject { index.inspect }
+
+      it do
+        is_expected.to eq %Q{
+          |#<DaruLite::MultiIndex(12x3)>
+          |   a one bar
+          |         baz
+          |     two bar
+          |         baz
+          |   b one bar
+          |     two bar
+          |         baz
+          |     one foo
+          |   c one bar
+          |         baz
+          |     two foo
+          |         bar
         }.unindent
-      }
+      end
     end
 
     context 'large index' do
@@ -331,7 +327,7 @@ describe DaruLite::MultiIndex do
 
     context 'multi index with name having empty string' do
       subject {
-        mi= DaruLite::MultiIndex.new(
+        DaruLite::MultiIndex.new(
                   levels: [[:a,:b,:c],[:one,:two],[:bar, :baz, :foo]],
                   labels: [
                     [0,0,0,0,1,1,1,1,2,2,2,2],
@@ -677,4 +673,17 @@ describe DaruLite::MultiIndex do
            'col3' => %w[bar bar baz foo]
     )}
   end
+
+  describe '#delete_at' do
+    subject { index.delete_at(3)}
+
+    let(:index) do
+      DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]])
+    end
+    let(:expected_index) do
+      DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:c, :one]])
+    end
+
+    it { is_expected.to eq(expected_index) }
+  end
 end

data/spec/vector/aggregatable_example.rb

@@ -0,0 +1,27 @@
+shared_examples_for 'an aggregatable Vector' do
+  context "#group_by" do
+    let(:dv) { DaruLite::Vector.new [:a, :b, :a, :b, :c] }
+
+    context 'vector not specified' do
+      subject { dv.group_by }
+
+      it { is_expected.to be_a DaruLite::Core::GroupBy }
+      its(:'groups.size') { is_expected.to eq 3 }
+      its(:groups) { is_expected.to eq({[:a]=>[0, 2], [:b]=>[1, 3], [:c]=>[4]}) }
+    end
+
+    context 'vector name specified' do
+      before { dv.name = :hello }
+      subject { dv.group_by :hello }
+
+      it { is_expected.to be_a DaruLite::Core::GroupBy }
+      its(:'groups.size') { is_expected.to eq 3 }
+      its(:groups) { is_expected.to eq({[:a]=>[0, 2], [:b]=>[1, 3], [:c]=>[4]}) }
+    end
+
+    context 'vector name invalid' do
+      before { dv.name = :hello }
+      it { expect { dv.group_by :abc }.to raise_error }
+    end
+  end
+end

data/spec/vector/calculatable_example.rb

@@ -0,0 +1,82 @@
+shared_examples_for 'a calculatable Vector' do |dtype|
+  describe '#count_values' do
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, 1, 2, nil, nil]) }
+
+    it { expect(vector.count_values 1, 2).to eq 4 }
+    it { expect(vector.count_values nil).to eq 2 }
+    it { expect(vector.count_values 3, Float::NAN).to eq 1 }
+    it { expect(vector.count_values 4).to eq 0 }
+  end
+
+  context "#summary" do
+    subject { vector.summary }
+
+    context 'all types' do
+      let(:vector) { DaruLite::Vector.new([1 ,2, 3, 4, 5], name: 'vector') }
+
+      it { is_expected.to include vector.name }
+
+      it { is_expected.to include "n :#{vector.size}" }
+
+      it { is_expected.to include "non-missing:#{vector.size - vector.count_values(*DaruLite::MISSING_VALUES)}" }
+    end
+
+
+    context "numeric type" do
+      let(:vector) { DaruLite::Vector.new([1,2,5], name: 'numeric') }
+
+      it { is_expected. to eq %Q{
+          |= numeric
+          |  n :3
+          |  non-missing:3
+          |  median: 2
+          |  mean: 2.6667
+          |  std.dev.: 2.0817
+          |  std.err.: 1.2019
+          |  skew: 0.2874
+          |  kurtosis: -2.3333
+        }.unindent }
+    end
+
+    context "numeric type with missing values" do
+      let(:vector) { DaruLite::Vector.new([1,2,5,nil,Float::NAN], name: 'numeric') }
+
+      it { is_expected.not_to include 'skew' }
+      it { is_expected.not_to include 'kurtosis' }
+    end
+
+    if dtype == :array
+      context "object type" do
+        let(:vector) { DaruLite::Vector.new([1, 1, 2, 2, "string", nil, Float::NAN], name: 'object') }
+
+        if RUBY_VERSION >= '2.2'
+          it { is_expected.to eq %Q{
+              |= object
+              |  n :7
+              |  non-missing:5
+              |  factors: 1,2,string
+              |  mode: 1,2
+              |  Distribution
+              |          string       1  50.00%
+              |             NaN       1  50.00%
+              |               1       2 100.00%
+              |               2       2 100.00%
+            }.unindent }
+        else
+          it { is_expected.to eq %Q{
+            |= object
+            |  n :7
+            |  non-missing:5
+            |  factors: 1,2,string
+            |  mode: 1,2
+            |  Distribution
+            |             NaN       1  50.00%
+            |          string       1  50.00%
+            |               2       2 100.00%
+            |               1       2 100.00%
+          }.unindent }
+        end
+      end
+    end
+  end
+end

data/spec/vector/convertible_example.rb

@@ -0,0 +1,126 @@
+shared_examples_for 'a convertible Vector' do |dtype|
+  describe "#to_df" do
+    subject { vector.to_df }
+
+    let(:vector) do
+      DaruLite::Vector.new(['a','b','c'], name: :my_dv, index: ['alpha', 'beta', 'gamma'])
+    end
+
+    it 'is a dataframe' do
+      expect(subject).to be_a DaruLite::DataFrame
+    end
+
+    it 'converts the vector to a single-vector dataframe' do
+      expect(subject[:my_dv]).to eq vector
+    end
+
+    it 'has the same index as the original vector' do
+      expect(subject.index).to eq vector.index
+    end
+
+    it 'has the same name as the vector' do
+      expect(subject.name).to eq :my_dv
+    end
+  end
+
+  describe "#to_h" do
+    context DaruLite::Index do
+      subject { vector.to_h }
+
+      let(:vector) do
+        DaruLite::Vector.new(
+          [1,2,3,4,5],
+          name: :a,
+          index: [:one, :two, :three, :four, :five],
+          dtype:
+        )
+      end
+
+      it "returns the vector as a hash" do
+        expect(subject).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      pending
+      # it "returns vector as a Hash" do
+      #   pending
+      #   mi = DaruLite::MultiIndex.from_tuples([
+      #     [:a,:two,:bar],
+      #     [:a,:two,:baz],
+      #     [:b,:one,:bar],
+      #     [:b,:two,:bar]
+      #   ])
+      #   vector = DaruLite::Vector.new([1,2,3,4], index: mi, dtype: dtype)
+      #   expect(vector.to_h).to eq({
+      #     [:a,:two,:bar] => 1,
+      #     [:a,:two,:baz] => 2,
+      #     [:b,:one,:bar] => 3,
+      #     [:b,:two,:bar] => 4
+      #   })
+      # end
+    end
+  end
+
+  describe "#to_json" do
+    subject { vector.to_json }
+
+    let(:vector) do
+      DaruLite::Vector.new(
+        [1,2,3,4,5],
+        name: :a,
+        index: [:one, :two, :three, :four, :five],
+        dtype: dtype
+      )
+    end
+
+    it "returns the vector as json" do
+      expect(subject).to eq(vector.to_h.to_json)
+    end
+
+  end
+
+  describe "#to_s" do
+    let(:vector) { DaruLite::Vector.new(["a", "b"], index: [1, 2], name:) }
+
+    context 'name is nil' do
+      let(:name) { nil }
+
+      it 'produces a class, size description' do
+        expect(vector.to_s).to eq("#<DaruLite::Vector(2)>")
+      end
+    end
+
+    context 'name is present' do
+      let(:name) { "Test" }
+
+      it 'produces a class, name, size description' do
+        expect(vector.to_s).to eq("#<DaruLite::Vector: Test(2)>")
+      end
+    end
+
+    context 'name is a symbol' do
+      let(:name) { :Test }
+
+      it 'produces a class, name, size description' do
+        expect(vector.to_s).to eq("#<DaruLite::Vector: Test(2)>")
+      end
+    end
+  end
+
+  describe "#to_matrix" do
+    let(:vector) { DaruLite::Vector.new [1, 2, 3, 4, 5, 6] }
+
+    it "converts DaruLite::Vector to a horizontal Ruby Matrix" do
+      expect(vector.to_matrix).to eq(Matrix[[1, 2, 3, 4, 5, 6]])
+    end
+
+    it "converts DaruLite::Vector to a vertical Ruby Matrix" do
+      expect(vector.to_matrix(:vertical)).to eq(Matrix.columns([[1, 2, 3, 4, 5, 6]]))
+    end
+
+    it 'raises on wrong axis' do
+      expect { vector.to_matrix(:strange) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/vector/duplicatable_example.rb

@@ -0,0 +1,48 @@
+shared_examples_for 'a duplicatable Vector' do
+  describe "#dup" do
+    subject { vector.dup }
+
+    let(:vector) do
+      DaruLite::Vector.new([1, 2], name: :yoda, index: [:happy, :lightsaber])
+    end
+
+    it "copies the original data" do
+      expect(subject.send(:data)).to eq([1,2])
+    end
+
+    it "creates a new data object" do
+      expect(subject.send(:data).object_id).not_to eq(vector.send(:data).object_id)
+    end
+
+    it "copies the name" do
+      expect(subject.name).to eq(:yoda)
+    end
+
+    it "copies the original index" do
+      expect(subject.index).to eq(DaruLite::Index.new([:happy, :lightsaber]))
+    end
+
+    it "creates a new index object" do
+      expect(subject.index.object_id).not_to eq(vector.index.object_id)
+    end
+  end
+
+  describe "#clone_structure" do
+    subject { vector.clone_structure }
+    context DaruLite::Index do
+      let(:vector) do
+        DaruLite::Vector.new([1, 2, 3, 4, 5], index: [:a,:b,:c,:d,:e])
+      end
+
+      it "clones a vector with its index and fills it with nils" do
+        expect(subject).to eq(
+          DaruLite::Vector.new([nil, nil, nil, nil, nil], index: [:a,:b,:c,:d,:e])
+        )
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      pending
+    end
+  end
+end