daru_lite 0.1 → 0.1.2

data/spec/index/index_spec.rb

@@ -389,6 +389,14 @@ describe DaruLite::Index do
 
   end
 
+  describe '#delete_at' do
+    subject { idx.delete_at(1)}
+
+    let(:idx) { DaruLite::Index.new([:a, :b, 1, 2]) }
+
+    it { is_expected.to eq DaruLite::Index.new([:a, 1, 2]) }
+  end
+
   context '#to_df' do
     let(:idx) do
       DaruLite::Index.new(['speaker', 'mic', 'guitar', 'amp'],

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