daru 0.1.5 → 0.3

data/spec/formatters/table_formatter_spec.rb

@@ -105,4 +105,33 @@ describe Daru::Formatters::Table do
       }.unindent}
     end
   end
+
+  context 'no row and column headers' do
+    let(:headers) { nil }
+    let(:row_headers) { nil }
+    it { is_expected.to eq %Q{
+        |       1   2   3
+        |       4   5   6
+        |       7   8   9
+      }.unindent }
+  end
+
+  context 'row headers only' do
+    let(:headers) { nil }
+    it { is_expected.to eq %Q{
+        | row1    1    2    3
+        | row2    4    5    6
+        | row3    7    8    9
+      }.unindent }
+  end
+
+  context 'column headers only' do
+    let(:row_headers) { nil }
+    it { is_expected.to eq %Q{
+        |      col1 col2 col3
+        |         1    2    3
+        |         4    5    6
+        |         7    8    9
+      }.unindent }
+  end
 end

data/spec/index/categorical_index_spec.rb

@@ -7,13 +7,13 @@ describe Daru::CategoricalIndex do
 
       context "single category" do
         subject { idx.pos :a }
-        
+
         it { is_expected.to eq [0, 2, 3] }
       end
-      
+
       context "multiple categories" do
         subject { idx.pos :a, :c }
-        
+
         it { is_expected.to eq [0, 2, 3, 4] }
       end
 
@@ -56,23 +56,23 @@ describe Daru::CategoricalIndex do
       end
     end
   end
-  
+
   context "#subset" do
     let(:idx) { described_class.new [:a, 1, :a, 1, :c] }
-    
+
     context "single index" do
       context "multiple instances" do
         subject { idx.subset :a }
-        
+
         it { is_expected.to be_a described_class }
         its(:size) { is_expected.to eq 2 }
         its(:to_a) { is_expected.to eq [:a, :a] }
       end
     end
-    
+
     context "multiple indexes" do
       subject { idx.subset :a, 1 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 4 }
       its(:to_a) { is_expected.to eq [:a, 1, :a, 1] }
@@ -80,79 +80,79 @@ describe Daru::CategoricalIndex do
 
     context "multiple positional indexes" do
       subject { idx.subset 0, 2 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
       its(:to_a) { is_expected.to eq [:a, :a] }
     end
   end
-  
+
   context "#at" do
     let(:idx) { described_class.new [:a, :a, :a, 1, :c] }
-    
+
     context "single position" do
       it { expect(idx.at 1).to eq :a }
     end
-    
+
     context "multiple positions" do
       subject { idx.at 0, 2, 3 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 3 }
       its(:to_a) { is_expected.to eq [:a, :a, 1] }
     end
-    
+
     context "range" do
       subject { idx.at 2..3 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
-      its(:to_a) { is_expected.to eq [:a, 1] }   
+      its(:to_a) { is_expected.to eq [:a, 1] }
     end
-    
+
     context "range with negative integers" do
       subject { idx.at 2..-2 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
-      its(:to_a) { is_expected.to eq [:a, 1] }   
-    end    
-    
+      its(:to_a) { is_expected.to eq [:a, 1] }
+    end
+
     context "rangle with single element" do
       subject { idx.at 2..2 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 1 }
-      its(:to_a) { is_expected.to eq [:a] }      
+      its(:to_a) { is_expected.to eq [:a] }
     end
-    
+
     context "invalid position" do
       it { expect { idx.at 5 }.to raise_error IndexError }
     end
-    
+
     context "invalid positions" do
       it { expect { idx.at 2, 5 }.to raise_error IndexError }
-    end    
+    end
   end
-  
+
   context "#add" do
     let(:idx) { described_class.new [:a, 1, :a, 1] }
-    
+
     context "single index" do
       subject { idx.add :c }
-      
+
       its(:to_a) { is_expected.to eq [:a, 1, :a, 1, :c] }
       its(:categories) { is_expected.to eq [:a, 1, :c] }
     end
-    
+
     context "multiple indexes" do
       subject { idx.add :c, :d }
-      
+
       its(:to_a) { is_expected.to eq [:a, 1, :a, 1, :c, :d] }
       its(:categories) { is_expected.to eq [:a, 1, :c, :d] }
     end
   end
-  
+
   context "#valid?" do
     let(:idx) { described_class.new [:a, 1, :a, 1] }
 
@@ -161,7 +161,7 @@ describe Daru::CategoricalIndex do
       it { expect(idx.valid? 2).to eq true }
       it { expect(idx.valid? 4).to eq false }
     end
-    
+
     context "multiple indexes" do
       it { expect(idx.valid? :a, 1).to eq true }
       it { expect(idx.valid? :a, 1, 5).to eq false }

data/spec/index/index_spec.rb

@@ -28,6 +28,25 @@ describe Daru::Index do
       expect(i.to_a).to eq([DateTime.new(2012,2,4), DateTime.new(2012,2,5), DateTime.new(2012,2,6)])
       expect(i.frequency).to eq('D')
     end
+
+    context "create an Index with name" do
+      context 'if no name is set' do
+        subject { Daru::Index.new [:a, :b, :c]  }
+        its(:name) { is_expected.to be_nil }
+      end
+
+      context 'correctly return the index name' do
+        subject { Daru::Index.new [:a, :b, :c], name: 'index_name'  }
+        its(:name) { is_expected.to eq 'index_name' }
+      end
+
+      context "set new index name" do
+        subject {
+          Daru::Index.new([:a, :b, :c], name: 'index_name') }
+        before { subject.name = 'new_name'}
+        its(:name) { is_expected.to eq 'new_name' }
+      end
+    end
   end
 
   context "#initialize" do
@@ -70,6 +89,25 @@ describe Daru::Index do
     end
   end
 
+  context '#sort' do
+    let(:asc) { index.sort }
+    let(:desc) { index.sort(ascending: false) }
+
+    context 'string index' do
+      let(:index) { Daru::Index.new ['mic', 'amp', 'guitar', 'speaker'] }
+      specify { expect(asc).to eq Daru::Index.new ['amp', 'guitar', 'mic',
+       'speaker'] }
+      specify { expect(desc).to eq Daru::Index.new ['speaker', 'mic', 'guitar',
+       'amp'] }
+    end
+
+    context 'number index' do
+      let(:index) { Daru::Index.new [100, 99, 101, 1, 2]  }
+      specify { expect(asc).to eq Daru::Index.new [1, 2, 99, 100, 101] }
+      specify { expect(desc).to eq Daru::Index.new [101, 100, 99, 2, 1] }
+    end
+  end
+
   context "#size" do
     it "correctly returns the size of the index" do
       idx = Daru::Index.new ['speaker', 'mic', 'guitar', 'amp']
@@ -77,15 +115,15 @@ describe Daru::Index do
       expect(idx.size).to eq(4)
     end
   end
-  
+
   context "#valid?" do
     let(:idx) { Daru::Index.new [:a, :b, :c] }
-    
+
     context "single index" do
       it { expect(idx.valid? 2).to eq true }
       it { expect(idx.valid? :d).to eq false }
     end
-    
+
     context "multiple indexes" do
       it { expect(idx.valid? :a, 1).to eq true }
       it { expect(idx.valid? :a, 3).to eq false }
@@ -102,6 +140,11 @@ describe Daru::Index do
       subject { Daru::Index.new ('a'..'z').to_a  }
       its(:inspect) { is_expected.to eq "#<Daru::Index(26): {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t ... z}>" }
     end
+
+    context 'index with name' do
+      subject { Daru::Index.new ['one', 'two', 'three'], name: 'number'  }
+      its(:inspect) { is_expected.to eq "#<Daru::Index(3): number {one, two, three}>" }
+    end
   end
 
   context "#&" do
@@ -142,25 +185,25 @@ describe Daru::Index do
     end
 
     it "works with ranges" do
-      expect(@id[:two..:five]).to eq(Daru::Index.new([:two, :three, :four, :five]))
+      expect(@id[:two..:five]).to eq([1, 2, 3, 4])
 
-      expect(@mixed_id['a'..'c']).to eq(Daru::Index.new(['a','b','c']))
+      expect(@mixed_id['a'..'c']).to eq([0, 1, 2])
 
-      # If both start and end are numbers then refer to numerical indexes
-      expect(@mixed_id[0..2]).to eq(Daru::Index.new(['a','b','c']))
+      # returns nil if first index is invalid
+      expect(@mixed_id.slice('d', 5)).to be_nil
 
-      # If atleast one is a number then refer to actual indexing
-      expect(@mixed_id.slice('b',8)).to eq(Daru::Index.new(['b','c',:d,:a,8]))
+      # returns positions till the end if first index is present
+      expect(@mixed_id.slice('c', 6)).to eq([2, 3, 4, 5, 6, 7])
     end
 
     it "returns multiple keys if specified multiple indices" do
-      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']))
+      expect(@id[:one, :two, :four, :five]).to eq([0, 1, 3, 4])
+      expect(@mixed_id[0,5,3,2]).to eq([nil, 7, 6, nil])
     end
 
-    it "returns correct index position for non-numeric index" do
+    it "returns nil for invalid indexes" do
       expect(@id[:four]).to eq(3)
-      expect(@id[3]).to eq(3)
+      expect(@id[3]).to be_nil
     end
 
     it "returns correct index position for mixed index" do
@@ -171,14 +214,14 @@ describe Daru::Index do
 
   context "#pos" do
     let(:idx) { described_class.new [:a, :b, 1, 2] }
-    
+
     context "single index" do
       it { expect(idx.pos :a).to eq 0 }
     end
-    
+
     context "multiple indexes" do
       subject { idx.pos :a, 1 }
-      
+
       it { is_expected.to be_a Array }
       its(:size) { is_expected.to eq 2 }
       it { is_expected.to eq [0, 2] }
@@ -187,10 +230,10 @@ describe Daru::Index do
     context "single positional index" do
       it { expect(idx.pos 0).to eq 0 }
     end
-    
+
     context "multiple positional index" do
       subject { idx.pos 0, 3 }
-      
+
       it { is_expected.to be_a Array }
       its(:size) { is_expected.to eq 2 }
       it { is_expected.to eq [0, 3] }
@@ -204,78 +247,78 @@ describe Daru::Index do
       it { is_expected.to eq [1, 2, 3] }
     end
   end
-  
+
   context "#subset" do
     let(:idx) { described_class.new [:a, :b, 1, 2] }
-    
+
     context "multiple indexes" do
       subject { idx.subset :a, 1 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
       its(:to_a) { is_expected.to eq [:a, 1] }
     end
-    
+
     context "multiple positional indexes" do
       subject { idx.subset 0, 3 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
       its(:to_a) { is_expected.to eq [:a, 2] }
     end
-    
+
     context "range" do
       subject { idx.subset 1..3 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 3 }
       its(:to_a) { is_expected.to eq [:b, 1, 2] }
     end
   end
-  
+
   context "#at" do
     let(:idx) { described_class.new [:a, :b, 1 ] }
-    
+
     context "single position" do
       it { expect(idx.at 1).to eq :b }
     end
-    
+
     context "multiple positions" do
       subject { idx.at 1, 2 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
       its(:to_a) { is_expected.to eq [:b, 1] }
     end
-    
+
     context "range" do
       subject { idx.at 1..2 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
-      its(:to_a) { is_expected.to eq [:b, 1] }      
+      its(:to_a) { is_expected.to eq [:b, 1] }
     end
-    
+
     context "range with negative integer" do
       subject { idx.at 1..-1 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 2 }
-      its(:to_a) { is_expected.to eq [:b, 1] }      
-    end    
-    
+      its(:to_a) { is_expected.to eq [:b, 1] }
+    end
+
     context "rangle with single element" do
       subject { idx.at 1..1 }
-      
+
       it { is_expected.to be_a described_class }
       its(:size) { is_expected.to eq 1 }
-      its(:to_a) { is_expected.to eq [:b] }      
+      its(:to_a) { is_expected.to eq [:b] }
     end
-    
+
     context "invalid position" do
       it { expect { idx.at 3 }.to raise_error IndexError }
     end
-    
+
     context "invalid positions" do
       it { expect { idx.at 2, 3 }.to raise_error IndexError }
     end
@@ -295,4 +338,80 @@ describe Daru::Index do
       it { expect(idx.select {|w| w[0] == 'g' }).to eq(['guitar']) }
     end
   end
+
+  context "#is_values" do
+    let(:klass) { Daru::Vector }
+    let(:idx) { described_class.new [:one, 'one', 1, 2, 'two', nil, [1, 2]] }
+
+    context "no arguments" do
+      let(:answer) { [false, false, false, false, false, false, false] }
+      it { expect(idx.is_values).to eq klass.new(answer) }
+    end
+
+    context "single arguments" do
+      let(:answer) { [false, true, false, false, false, false, false] }
+      it { expect(idx.is_values 'one').to eq klass.new(answer) }
+    end
+
+    context "multiple arguments" do
+      context "symbol and number as argument" do
+        subject { idx.is_values 2, :one }
+        let(:answer) { [true, false, false, true, false, false, false] }
+        it { is_expected.to be_a Daru::Vector }
+        its(:size) { is_expected.to eq 7 }
+        it { is_expected.to eq klass.new(answer) }
+      end
+
+      context "string and number as argument" do
+        subject { idx.is_values('one', 1)}
+        let(:answer) { [false, true, true, false, false, false, false] }
+        it { is_expected.to be_a Daru::Vector }
+        its(:size) { is_expected.to eq 7 }
+        it { is_expected.to eq klass.new(answer) }
+      end
+
+      context "nil is present in arguments" do
+        subject { idx.is_values('two', nil)}
+        let(:answer) { [false, false, false, false, true, true, false] }
+        it { is_expected.to be_a Daru::Vector }
+        its(:size) { is_expected.to eq 7 }
+        it { is_expected.to eq klass.new(answer) }
+      end
+
+      context "subarray is present in arguments" do
+        subject { idx.is_values([1, 2])}
+        let(:answer) { [false, false, false, false, false, false, true] }
+        it { is_expected.to be_a Daru::Vector }
+        its(:size) { is_expected.to eq 7 }
+        it { is_expected.to eq klass.new(answer) }
+      end
+    end
+
+  end
+
+  context '#to_df' do
+    let(:idx) do
+      Daru::Index.new(['speaker', 'mic', 'guitar', 'amp'],
+                      name: 'instruments')
+    end
+    subject { idx.to_df }
+
+    it { is_expected.to eq Daru::DataFrame.new(
+           'instruments' => ['speaker', 'mic', 'guitar', 'amp']
+         )
+    }
+  end
+
+  context "#dup" do
+    let(:idx) do
+      Daru::Index.new(['speaker', 'mic', 'guitar', 'amp'],
+                      name: 'instruments')
+    end
+    subject { idx.dup }
+
+    it { is_expected.to eq idx }
+    it 'have same names' do
+      expect(subject.name).to eq idx.name
+    end
+  end
 end