daru_lite 0.1.1 → 0.1.3

data/spec/vector/indexable_example.rb

@@ -0,0 +1,201 @@
+shared_examples_for 'an indexable Vector' do |dtype|
+  describe "#index_of" do
+    context DaruLite::Index do
+      let(:vector) do
+        DaruLite::Vector.new(
+          [1,2,3,4,5],
+          name: :a,
+          index: [:one, :two, :three, :four, :five],
+          dtype:
+        )
+      end
+      it "returns index of specified value" do
+        expect(vector.index_of(1)).to eq(:one)
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let(:vector) { DaruLite::Vector.new([1,2,3,4], index: multi_index, dtype:) }
+      let(:multi_index) do
+        DaruLite::MultiIndex.from_tuples([
+          [:a,:two,:bar],
+          [:a,:two,:baz],
+          [:b,:one,:bar],
+          [:b,:two,:bar]
+        ])
+      end
+
+      it "returns tuple of specified value" do
+        expect(vector.index_of(3)).to eq([:b,:one,:bar])
+      end
+    end
+  end
+
+  describe "#index=" do
+    subject { vector.index = new_index }
+
+    let(:vector) { DaruLite::Vector.new([1,2,3,4,5]) }
+
+    context "new index is an Index" do
+      before { subject }
+
+      let(:new_index) { DaruLite::DateTimeIndex.date_range(start: '2012', periods: 5) }
+
+      it 'returns the new index' do
+        expect(subject).to eq(new_index)
+      end
+
+      it "simply reassigns index" do
+        expect(vector.index.class).to eq(DaruLite::DateTimeIndex)
+        expect(vector['2012-1-1']).to eq(1)
+      end
+    end
+
+    context "new index is an array" do
+      before { subject }
+
+      let(:new_index) { [5, 4, 3, 2, 1] }
+
+      it "accepts an array as index" do
+        expect(vector.index.class).to eq(DaruLite::Index)
+        expect(vector[5]).to eq(1)
+      end
+    end
+
+    context "new index is a range" do
+      before { subject }
+
+      let(:new_index) { 'a'..'e' }
+
+      it "accepts an range as index" do
+        expect(vector.index.class).to eq(DaruLite::Index)
+        expect(vector['a']).to eq(1)
+      end
+    end
+
+    context "new index has a different size" do
+      let(:new_index) { DaruLite::Index.new([4,2,6]) }
+
+      it "raises error for index size != vector size" do
+        expect { subject }.to raise_error(
+          ArgumentError, 'Size of supplied index 3 does not match size of Vector'
+        )
+      end
+    end
+  end
+
+  describe "#reindex!" do
+    subject { vector.reindex!(index) }
+
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, 4, 5]) }
+    let(:index) { DaruLite::Index.new([3, 4, 1, 0, 6]) }
+
+    before { subject }
+
+    it "intelligently reindexes" do
+      expect(vector).to eq(DaruLite::Vector.new([4, 5, 2, 1, nil], index:))
+    end
+  end
+
+  describe "#reindex" do
+    subject { vector.reindex(index) }
+
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, 4, 5]) }
+    let(:index) { DaruLite::Index.new([3, 4, 1, 0, 6]) }
+
+    it "intelligently reindexes" do
+      expect(subject).to eq(DaruLite::Vector.new([4, 5, 2, 1, nil], index:))
+    end
+  end
+
+  describe '#indexes' do
+    context DaruLite::Index do
+      subject { vector.indexes 1, 2, nil, Float::NAN }
+
+      let(:vector) do
+        DaruLite::Vector.new(
+          [1, 2, 1, 2, 3, nil, nil, Float::NAN],
+          index: 11..18
+        )
+      end
+
+      it { is_expected.to be_a Array }
+      it { is_expected.to eq [11, 12, 13, 14, 16, 17, 18] }
+    end
+
+    context DaruLite::MultiIndex do
+      subject { vector.indexes 1, 2, Float::NAN }
+
+      let(:mi) do
+        DaruLite::MultiIndex.from_tuples([
+          ['M', 2000],
+          ['M', 2001],
+          ['M', 2002],
+          ['M', 2003],
+          ['F', 2000],
+          ['F', 2001],
+          ['F', 2002],
+          ['F', 2003]
+        ])
+      end
+      let(:vector) { DaruLite::Vector.new([1, 2, 1, 2, 3, nil, nil, Float::NAN], index: mi) }
+
+      it { is_expected.to be_a Array }
+      it { is_expected.to eq(
+        [
+          ['M', 2000],
+          ['M', 2001],
+          ['M', 2002],
+          ['M', 2003],
+          ['F', 2003]
+        ]) }
+    end
+  end
+
+  describe "#reset_index!" do
+    subject { vector.reset_index! }
+
+    context 'after rejecting initial values' do
+      let(:vector) do
+        v = DaruLite::Vector.new([1, 2, 3, 4, 5, nil, nil, 4, nil])
+        v.reject_values(*DaruLite::MISSING_VALUES)
+      end
+
+      it "resets any index to a numerical serialized index" do
+        expect(subject).to eq(DaruLite::Vector.new([1, 2, 3, 4, 5, 4]))
+        expect(subject.index).to eq(DaruLite::Index.new([0, 1, 2, 3, 4, 5]))
+      end
+    end
+
+    context 'when vector is indexed' do
+      let(:vector) do
+        DaruLite::Vector.new([1, 2, 3, 4, 5], index: [:a, :b, :c, :d, :e])
+      end
+
+      it "resets any index to a numerical serialized index" do
+        expect(subject.index).to eq(DaruLite::Index.new([0, 1, 2, 3, 4]))
+      end
+    end
+  end
+
+  describe "#detach_index" do
+    subject { vector.detach_index }
+
+    let(:vector) do
+      DaruLite::Vector.new(
+        [1, 2, 3, 4, 5, 6],
+        index: ['a', 'b', 'c', 'd', 'e', 'f'],
+        name: :values
+      )
+    end
+
+    it "creates a DataFrame with first Vector as index and second as values of the Vector" do
+      expect(vector.detach_index).to eq(
+        DaruLite::DataFrame.new(
+          index: ['a', 'b', 'c', 'd', 'e', 'f'],
+          values: [1, 2, 3, 4, 5, 6]
+        )
+      )
+    end
+  end
+end

data/spec/vector/iterable_example.rb

@@ -0,0 +1,111 @@
+shared_examples_for 'an iterable Vector' do |dtype|
+  let(:vector) do
+    DaruLite::Vector.new(
+      [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99],
+      dtype:,
+      name: :common_all_dtypes
+    )
+  end
+
+  describe "#collect" do
+    subject { vector.collect { |v| v } }
+
+    it "returns an Array" do
+      expect(subject).to eq([5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99])
+    end
+  end
+
+  describe "#map" do
+    subject { vector.map { |v| v } }
+
+    it "maps" do
+      expect(subject).to eq([5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99])
+    end
+  end
+
+  describe "#map!" do
+    subject { vector.map! { |v| v + 1 } }
+
+    it "destructively maps" do
+      subject
+      expect(vector).to eq(
+        DaruLite::Vector.new(
+          [6, 6, 6, 6, 6, 7, 7, 8, 9, 10, 11, 2, 3, 4, 5, 12, -98, -98],
+          dtype:
+        )
+      )
+    end
+  end
+
+  describe "#recode" do
+    subject { vector.recode { |v| v == -99 ? 1 : 0 } }
+
+    it "maps and returns a vector of dtype of self by default" do
+      expect(subject).to eq(
+        DaruLite::Vector.new [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1]
+      )
+      expect(subject.dtype).to eq(:array)
+    end
+  end
+
+  describe "#recode!" do
+    subject { vector.recode! { |v| v == -99 ? 1 : 0 } }
+
+    let(:vector) do
+      DaruLite::Vector.new(
+        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, 11, -99, -99],
+        name: :common_all_dtypes,
+        dtype:
+      )
+    end
+
+    it "destructively maps and returns a vector of dtype of self by default" do
+      subject
+      expect(vector).to eq(
+        DaruLite::Vector.new [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1]
+      )
+      expect(vector.dtype).to eq(dtype)
+    end
+  end
+
+  describe "#verify" do
+    subject { vector.verify { |d| d > 0 } }
+
+    let(:vector) do
+      DaruLite::Vector.new([1,2,3,4,5,6,-99,35,-100], dtype:)
+    end
+
+    it "returns a hash of invalid data and index of data" do
+      expect(subject).to eq({ 6 => -99, 8 => -100 })
+    end
+  end
+
+  describe '#replace_values' do
+    subject do
+      DaruLite::Vector.new(
+        [1, 2, 1, 4, nil, Float::NAN, nil, Float::NAN],
+        index: 11..18
+      )
+    end
+
+    context 'replace nils and NaNs' do
+      before { subject.replace_values [nil, Float::NAN], 10 }
+
+      its(:to_a) { is_expected.to eq [1, 2, 1, 4, 10, 10, 10, 10] }
+    end
+
+    context 'replace arbitrary values' do
+      before { subject.replace_values [1, 2], 10 }
+
+      its(:to_a) { is_expected.to eq(
+        [10, 10, 10, 4, nil, Float::NAN, nil, Float::NAN]) }
+    end
+
+    context 'works for single value' do
+      before { subject.replace_values nil, 10 }
+
+      its(:to_a) { is_expected.to eq(
+        [1, 2, 1, 4, 10, Float::NAN, 10, Float::NAN]) }
+    end
+  end
+end

data/spec/vector/joinable_example.rb

@@ -0,0 +1,25 @@
+shared_examples_for 'a joinable Vector' do |dtype|
+  describe "#concat" do
+    let(:vector) do
+      DaruLite::Vector.new(
+        [1, 2, 3, 4, 5],
+        name: :yoga,
+        index: [:warwick, :thompson, :jackson, :fender, :esp],
+        dtype:
+      )
+    end
+
+    it "concatenates a new element at the end of vector with index" do
+      vector.concat(6, :ibanez)
+
+      expect(vector.index)   .to eq(
+        DaruLite::Index.new([:warwick, :thompson, :jackson, :fender, :esp, :ibanez]))
+      expect(vector[:ibanez]).to eq(6)
+      expect(vector[5])      .to eq(6)
+    end
+
+    it "raises error if index not specified" do
+      expect { vector.concat(6) }.to raise_error
+    end
+  end
+end

data/spec/vector/missable_example.rb

@@ -0,0 +1,88 @@
+shared_examples_for 'a missable Vector' do
+  describe "#replace_nils" do
+    subject { vector.replace_nils(2) }
+
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, nil, nil, 4]) }
+
+    it "replaces all nils with the specified value" do
+      expect(subject).to eq(DaruLite::Vector.new([1, 2, 3, 2, 2, 4]))
+    end
+
+    it "replaces all nils with the specified value (bang)" do
+      vec = DaruLite::Vector.new([1,2,3,nil,nil,4]).replace_nils!(2)
+      expect(vec).to eq(DaruLite::Vector.new([1,2,3,2,2,4]))
+    end
+  end
+
+  describe "#replace_nils" do
+    subject { vector.replace_nils!(2) }
+
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, nil, nil, 4]) }
+
+    it "replaces all nils with the specified value (bang)" do
+      subject
+      expect(vector).to eq(DaruLite::Vector.new([1, 2, 3, 2, 2, 4]))
+    end
+  end
+
+  describe '#rolling_fillna!' do
+    subject do
+      DaruLite::Vector.new(
+        [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN]
+      )
+    end
+
+    context 'rolling_fillna! forwards' do
+      before { subject.rolling_fillna!(:forward) }
+
+      its(:to_a) { is_expected.to eq [0, 2, 1, 4, 4, 4, 3, 3, 3] }
+    end
+
+    context 'rolling_fillna! backwards' do
+      before { subject.rolling_fillna!(direction: :backward) }
+
+      its(:to_a) { is_expected.to eq [2, 2, 1, 4, 3, 3, 3, 0, 0] }
+    end
+
+    context 'all invalid vector' do
+      subject do
+        DaruLite::Vector.new(
+          [Float::NAN, Float::NAN, Float::NAN, Float::NAN, Float::NAN]
+        )
+      end
+
+      before { subject.rolling_fillna!(:forward) }
+
+      its(:to_a) { is_expected.to eq [0, 0, 0, 0, 0] }
+    end
+
+    context 'with non-default index' do
+      subject do
+        DaruLite::Vector.new(
+          [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN],
+          index: %w[a b c d e f g h i]
+        )
+      end
+
+      before { subject.rolling_fillna!(direction: :backward) }
+
+      it { is_expected.to eq DaruLite::Vector.new([2, 2, 1, 4, 3, 3, 3, 0, 0], index: %w[a b c d e f g h i]) }
+    end
+  end
+
+  describe '#rolling_fillna' do
+    subject do
+      DaruLite::Vector.new(
+        [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN]
+      )
+    end
+
+    context 'rolling_fillna forwards' do
+      it { expect(subject.rolling_fillna(:forward).to_a).to eq [0, 2, 1, 4, 4, 4, 3, 3, 3] }
+    end
+
+    context 'rolling_fillna backwards' do
+      it { expect(subject.rolling_fillna(direction: :backward).to_a).to eq [2, 2, 1, 4, 3, 3, 3, 0, 0] }
+    end
+  end
+end

data/spec/vector/queryable_example.rb

@@ -0,0 +1,91 @@
+shared_examples_for 'a queryable Vector' do
+  describe '#include_values?' do
+    context 'only nils' do
+      context 'true' do
+        let(:vector) { DaruLite::Vector.new [1, 2, 3, :a, 'Unknown', nil] }
+        it { expect(vector.include_values? nil).to eq true }
+      end
+
+      context 'false' do
+        let(:vector) { DaruLite::Vector.new [1, 2, 3, :a, 'Unknown'] }
+        it { expect(vector.include_values? nil).to eq false }
+      end
+    end
+
+    context 'only Float::NAN' do
+      context 'true' do
+        let(:vector) { DaruLite::Vector.new [1, nil, 2, 3, Float::NAN] }
+        it { expect(vector.include_values? Float::NAN).to eq true }
+      end
+
+      context 'false' do
+        let(:vector) { DaruLite::Vector.new [1, nil, 2, 3] }
+        it { expect(vector.include_values? Float::NAN).to eq false }
+      end
+    end
+
+    context 'both nil and Float::NAN' do
+      context 'true with only nil' do
+        let(:vector) { DaruLite::Vector.new [1, Float::NAN, 2, 3] }
+        it { expect(vector.include_values? nil, Float::NAN).to eq true }
+      end
+
+      context 'true with only Float::NAN' do
+        let(:vector) { DaruLite::Vector.new [1, nil, 2, 3] }
+        it { expect(vector.include_values? nil, Float::NAN).to eq true }
+      end
+
+      context 'false' do
+        let(:vector) { DaruLite::Vector.new [1, 2, 3] }
+        it { expect(vector.include_values? nil, Float::NAN).to eq false }
+      end
+    end
+
+    context 'any other value' do
+      context 'true' do
+        let(:vector) { DaruLite::Vector.new [1, 2, 3, 4, nil] }
+        it { expect(vector.include_values? 1, 2, 3, 5).to eq true }
+      end
+
+      context 'false' do
+        let(:vector) { DaruLite::Vector.new [1, 2, 3, 4, nil] }
+        it { expect(vector.include_values? 5, 6).to eq false }
+      end
+    end
+  end
+
+  describe "#any?" do
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, 4, 5]) }
+
+    it "returns true if block returns true for any one of the elements" do
+      expect(vector.any?{ |e| e == 1 }).to eq(true)
+    end
+
+    it "returns false if block is false for all elements" do
+      expect(vector.any?{ |e| e > 10 }).to eq(false)
+    end
+  end
+
+  describe "#all?" do
+    let(:vector) { DaruLite::Vector.new([1, 2, 3, 4, 5]) }
+
+    it "returns true if block is true for all elements" do
+      expect(vector.all? { |e| e < 6 }).to eq(true)
+    end
+
+    it "returns false if block is false for any one element" do
+      expect(vector.all? { |e| e == 2 }).to eq(false)
+    end
+  end
+
+  describe '#match' do
+    subject { dv.match(regexp) }
+
+    context 'returns matching array for a given regexp' do
+      let(:dv)     { DaruLite::Vector.new ['3 days', '5 weeks', '2 weeks'] }
+      let(:regexp) { /weeks/ }
+
+      it { is_expected.to eq([false, true, true]) }
+    end
+  end
+end