daru_lite 0.1 → 0.1.2

data/lib/daru_lite/version.rb

@@ -1,3 +1,3 @@
 module DaruLite
-  VERSION = '0.1'.freeze
+  VERSION = '0.1.2'.freeze
 end

data/spec/data_frame/aggregatable_example.rb

@@ -0,0 +1,65 @@
+shared_examples_for 'an aggregatable DataFrame' do
+  describe "#group_by" do
+    context "on a single row DataFrame" do
+      subject { df.group_by([:city]) }
+
+      let(:df){ DaruLite::DataFrame.new(city: %w[Kyiv], year: [2015], value: [1]) }
+
+      it "returns a groupby object" do
+        expect(subject).to be_a(DaruLite::Core::GroupBy)
+      end
+
+      it "has the correct index" do
+        expect(subject.groups).to eq({["Kyiv"]=>[0]})
+      end
+    end
+  end
+
+  describe '#aggregate' do
+    let(:cat_idx) { DaruLite::CategoricalIndex.new [:a, :b, :a, :a, :c] }
+    let(:df) { DaruLite::DataFrame.new(num: [52,12,07,17,01], cat_index: cat_idx) }
+    let(:df_cat_idx) do
+      DaruLite::DataFrame.new({num: [52,12,07,17,01]}, index: cat_idx)
+    end
+
+    it 'lambda function on particular column' do
+      expect(df.aggregate(num_100_times: ->(df) { (df.num*100).first })).to eq(
+          DaruLite::DataFrame.new(num_100_times: [5200, 1200, 700, 1700, 100])
+        )
+    end
+
+    it 'aggregate sum on particular column' do
+      expect(df_cat_idx.aggregate(num: :sum)).to eq(
+          DaruLite::DataFrame.new({num: [76, 12, 1]}, index: [:a, :b, :c])
+        )
+    end
+  end
+
+  describe '#group_by_and_aggregate' do
+    let(:spending_df) do
+      DaruLite::DataFrame.rows([
+        [2010,    'dev',  50, 1],
+        [2010,    'dev', 150, 1],
+        [2010,    'dev', 200, 1],
+        [2011,    'dev',  50, 1],
+        [2012,    'dev', 150, 1],
+
+        [2011, 'office', 300, 1],
+
+        [2010, 'market',  50, 1],
+        [2011, 'market', 500, 1],
+        [2012, 'market', 500, 1],
+        [2012, 'market', 300, 1],
+
+        [2012,    'R&D',  10, 1],],
+        order: [:year, :category, :spending, :nb_spending])
+    end
+
+    it 'works as group_by + aggregate' do
+      expect(spending_df.group_by_and_aggregate(:year, spending: :sum)).to eq(
+        spending_df.group_by(:year).aggregate(spending: :sum))
+      expect(spending_df.group_by_and_aggregate([:year, :category], spending: :sum, nb_spending: :size)).to eq(
+        spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending: :size))
+    end
+  end
+end

data/spec/data_frame/buildable_example.rb

@@ -0,0 +1,109 @@
+shared_examples_for 'a buildable DataFrame' do
+  describe "::rows" do
+    let(:rows) do
+      [
+        [1,2,3,4,5],
+        [1,2,3,4,5],
+        [1,2,3,4,5],
+        [1,2,3,4,5]
+      ]
+    end
+
+    context DaruLite::Index do
+      it "creates a DataFrame from Array rows" do
+        df = DaruLite::DataFrame.rows(rows, order: [:a,:b,:c,:d,:e])
+
+        expect(df.index).to eq(DaruLite::Index.new [0,1,2,3])
+        expect(df.vectors).to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
+        expect(df[:a]).to eq(DaruLite::Vector.new [1,1,1,1])
+      end
+
+      it "creates empty dataframe" do
+        df = DaruLite::DataFrame.rows([], order: [:a, :b, :c])
+
+        expect(df.vectors).to eq(DaruLite::Index.new [:a,:b,:c])
+        expect(df.index).to be_empty
+      end
+
+      it "creates a DataFrame from Vector rows" do
+        vector_rows = rows.map { |r| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e] }
+
+        df = DaruLite::DataFrame.rows(vector_rows, order: [:a,:b,:c,:d,:e])
+
+        expect(df.index)      .to eq(DaruLite::Index.new [0,1,2,3])
+        expect(df.vectors)    .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
+        expect(df[:a]) .to eq(DaruLite::Vector.new [1,1,1,1])
+      end
+
+      it 'derives index & order from arrays' do
+        df = DaruLite::DataFrame.rows(rows)
+        expect(df.index)    .to eq(DaruLite::Index.new [0,1,2,3])
+        expect(df.vectors)  .to eq(DaruLite::Index.new %w[0 1 2 3 4])
+      end
+
+      it 'derives index & order from vectors' do
+        vector_rows = rows.zip(%w[w x y z]).map { |r, n| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
+        df = DaruLite::DataFrame.rows(vector_rows)
+        expect(df.index)    .to eq(DaruLite::Index.new %w[w x y z])
+        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
+      end
+
+      it 'behaves, when rows are repeated' do
+        vector_rows = rows.zip(%w[w w y z]).map { |r, n| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
+        df = DaruLite::DataFrame.rows(vector_rows)
+        expect(df.index)    .to eq(DaruLite::Index.new %w[w_1 w_2 y z])
+        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
+      end
+
+      it 'behaves, when vectors are unnamed' do
+        vector_rows = rows.map { |r| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e] }
+        df = DaruLite::DataFrame.rows(vector_rows)
+        expect(df.index)    .to eq(DaruLite::Index.new [0,1,2,3])
+        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      it "creates a DataFrame from rows" do
+        df = DaruLite::DataFrame.rows(
+          rows*3, index: multi_index, order: [:a,:b,:c,:d,:e])
+
+        expect(df.index).to eq(multi_index)
+        expect(df.vectors).to eq(DaruLite::Index.new([:a,:b,:c,:d,:e]))
+        expect(df[:a]).to eq(DaruLite::Vector.new([1]*12, index: multi_index))
+      end
+
+      it "crates a DataFrame from rows (MultiIndex order)" do
+        rows = [
+          [11, 1, 11, 1],
+          [12, 2, 12, 2],
+          [13, 3, 13, 3],
+          [14, 4, 14, 4]
+        ]
+        index = DaruLite::MultiIndex.from_tuples([
+          [:one,:bar],
+          [:one,:baz],
+          [:two,:foo],
+          [:two,:bar]
+        ])
+
+        df = DaruLite::DataFrame.rows(rows, index: index, order: order_mi)
+        expect(df.index).to eq(index)
+        expect(df.vectors).to eq(order_mi)
+        expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new([11,12,13,14],
+          index: index))
+      end
+
+      it "creates a DataFrame from Vector rows" do
+        rows3 = rows*3
+        rows3.map! { |r| DaruLite::Vector.new(r, index: multi_index) }
+
+        df = DaruLite::DataFrame.rows(rows3, order: multi_index)
+
+        expect(df.index).to eq(DaruLite::Index.new(Array.new(rows3.size) { |i| i }))
+        expect(df.vectors).to eq(multi_index)
+        expect(df[:a,:one,:bar]).to eq(DaruLite::Vector.new([1]*12))
+      end
+    end
+  end
+end

data/spec/data_frame/calculatable_example.rb

@@ -0,0 +1,135 @@
+shared_examples_for 'a calculatable DataFrame' do
+  context "#vector_sum" do
+    let(:df) do
+      a1 = DaruLite::Vector.new [1, 2, 3, 4, 5, nil, nil]
+      a2 = DaruLite::Vector.new [10, 10, 20, 20, 20, 30, nil]
+      b1 = DaruLite::Vector.new [nil, 1, 1, 1, 1, 2, nil]
+      b2 = DaruLite::Vector.new [2, 2, 2, nil, 2, 3, nil]
+      DaruLite::DataFrame.new({ a1:, a2:, b1:, b2: })
+    end
+
+    it "calculates complete vector sum" do
+      expect(df.vector_sum).to eq(DaruLite::Vector.new [nil, 15, 26, nil, 28, nil, nil])
+    end
+
+    it "ignores nils if skipnil is true" do
+      expect(df.vector_sum skipnil: true).to eq(DaruLite::Vector.new [13, 15, 26, 25, 28, 35, 0])
+    end
+
+    it "calculates partial vector sum" do
+      a = df.vector_sum([:a1, :a2])
+      b = df.vector_sum([:b1, :b2])
+
+      expect(a).to eq(DaruLite::Vector.new [11, 12, 23, 24, 25, nil, nil])
+      expect(b).to eq(DaruLite::Vector.new [nil, 3, 3, nil, 3, 5, nil])
+    end
+  end
+
+  describe "#vector_mean" do
+    let(:df) do
+      a1 = DaruLite::Vector.new [1, 2, 3, 4, 5, nil]
+      a2 = DaruLite::Vector.new [10, 10, 20, 20, 20, 30]
+      b1 = DaruLite::Vector.new [nil, 1, 1, 1, 1, 2]
+      b2 = DaruLite::Vector.new [2, 2, 2, nil, 2, 3]
+      c  = DaruLite::Vector.new [nil, 2, 4, 2, 2, 2]
+      DaruLite::DataFrame.new({ a1:, a2:, b1:, b2:, c: })
+    end
+
+    it "calculates complete vector mean" do
+      expect(df.vector_mean).to eq(
+        DaruLite::Vector.new [nil, 3.4, 6, nil, 6.0, nil]
+      )
+    end
+  end
+
+  describe "#compute" do
+    let(:vnumeric) { DaruLite::Vector.new [0, 0, 1, 4] }
+    let(:vsum) { DaruLite::Vector.new [1 + 4 + 10.0, 2 + 3 + 20.0, 3 + 2 + 30.0, 4 + 1 + 40.0] }
+    let(:vmult) { DaruLite::Vector.new [1 * 4, 2 * 3, 3 * 2, 4 * 1] }
+    let(:df) do
+      v1 = DaruLite::Vector.new [1, 2, 3, 4]
+      v2 = DaruLite::Vector.new [4, 3, 2, 1]
+      v3 = DaruLite::Vector.new [10, 20, 30, 40]
+
+      DaruLite::DataFrame.new({ v1:, v2:, v3: })
+    end
+
+    it "performs a computation when supplied in a string" do
+      expect(df.compute("v1/v2")).to eq(vnumeric)
+      expect(df.compute("v1+v2+v3")).to eq(vsum)
+      expect(df.compute("v1*v2")).to eq(vmult)
+    end
+  end
+
+  describe "#vector_by_calculation" do
+    subject { df.vector_by_calculation { a + b + c } }
+
+    let(:df) do
+      a1 = DaruLite::Vector.new([1, 2, 3, 4, 5, 6, 7])
+      a2 = DaruLite::Vector.new([10, 20, 30, 40, 50, 60, 70])
+      a3 = DaruLite::Vector.new([100, 200, 300, 400, 500, 600, 700])
+      DaruLite::DataFrame.new({ :a => a1, :b => a2, :c => a3 })
+    end
+
+    it "DSL for returning vector of each calculation" do
+      expect(subject).to eq(DaruLite::Vector.new([111, 222, 333, 444, 555, 666, 777]))
+    end
+  end
+
+  describe "#vector_count_characters" do
+    subject { df.vector_count_characters }
+    let(:df) do
+      a1 = DaruLite::Vector.new( [1, 'abcde', 3, 4, 5, nil])
+      a2 = DaruLite::Vector.new( [10, 20.3, 20, 20, 20, 30])
+      b1 = DaruLite::Vector.new( [nil, '343434', 1, 1, 1, 2])
+      b2 = DaruLite::Vector.new( [2, 2, 2, nil, 2, 3])
+      c  = DaruLite::Vector.new([nil, 2, 'This is a nice example', 2, 2, 2])
+
+      DaruLite::DataFrame.new({ a1:, a2:, b1:, b2:, c: })
+    end
+
+    it "returns correct values" do
+      expect(subject).to eq(DaruLite::Vector.new([4, 17, 27, 5, 6, 5]))
+    end
+  end
+
+  describe "#summary" do
+    subject { df.summary }
+
+    context "DataFrame" do
+      let(:df) do
+        DaruLite::DataFrame.new(
+          { a: [1,2,5], b: [1,2,"string"] },
+          order: [:a, :b],
+          index: [:one, :two, :three],
+          name: 'frame'
+        )
+      end
+
+      it { is_expected.to eq %Q{
+            |= frame
+            |  Number of rows: 3
+            |  Element:[a]
+            |  == a
+            |    n :3
+            |    non-missing:3
+            |    median: 2
+            |    mean: 2.6667
+            |    std.dev.: 2.0817
+            |    std.err.: 1.2019
+            |    skew: 0.2874
+            |    kurtosis: -2.3333
+            |  Element:[b]
+            |  == b
+            |    n :3
+            |    non-missing:3
+            |    factors: 1,2,string
+            |    mode: 1,2,string
+            |    Distribution
+            |                 1       1 100.00%
+            |                 2       1 100.00%
+            |            string       1 100.00%
+        }.unindent }
+    end
+  end
+end

data/spec/data_frame/convertible_example.rb

@@ -0,0 +1,180 @@
+shared_examples_for 'a convertible DataFrame' do
+  describe '#create_sql' do
+    subject { df.create_sql('foo') }
+
+    let(:df) do
+      DaruLite::DataFrame.new(
+        {
+          a: [1,2,3],
+          b: ['test', 'me', 'please'],
+          c: ['2015-06-01', '2015-06-02', '2015-06-03']
+        },
+        name: 'test'
+      )
+    end
+
+    it { is_expected.to eq %Q{
+      |CREATE TABLE foo (a INTEGER,
+      | b VARCHAR (255),
+      | c DATE) CHARACTER SET=UTF8;
+    }.unindent }
+  end
+
+  describe '#to_df' do
+    subject { df.to_df }
+
+    it { is_expected.to eq(df) }
+  end
+
+  describe "#to_matrix" do
+    subject { df.to_matrix }
+
+    let(:df) do
+      DaruLite::DataFrame.new(
+        {
+          b: [11,12,13,14,15],
+          a: [1,2,3,4,5],
+          c: [11,22,33,44,55],
+          d: [5,4,nil,2,1],
+          e: ['this', 'has', 'string','data','too']
+        },
+        order: [:a, :b, :c,:d,:e],
+        index: [:one, :two, :three, :four, :five]
+      )
+    end
+
+    it "concats numeric non-nil vectors to Matrix" do
+      expect(subject).to eq(Matrix[
+        [1,11,11,5],
+        [2,12,22,4],
+        [3,13,33,nil],
+        [4,14,44,2],
+        [5,15,55,1]
+      ])
+    end
+  end
+
+  describe "#to_a" do
+    subject { df.to_a }
+
+    context DaruLite::Index do
+      it "converts DataFrame into array of hashes" do
+        expect(subject).to eq(
+          [
+            [
+              {a: 1, b: 11, c: 11},
+              {a: 2, b: 12, c: 22},
+              {a: 3, b: 13, c: 33},
+              {a: 4, b: 14, c: 44},
+              {a: 5, b: 15, c: 55}
+            ],
+            [
+              :one, :two, :three, :four, :five
+            ]
+          ])
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      pending
+    end
+  end
+
+  describe '#to_json' do
+    subject { JSON.parse(json) }
+
+    let(:df) do
+      DaruLite::DataFrame.new(
+        { a: [1,2,3], b: [3,4,5], c: [6,7,8]},
+        index: [:one, :two, :three],
+        name: 'test'
+      )
+    end
+
+    context 'with index' do
+      let(:json) { df.to_json(false) }
+      # FIXME: is it most reasonable we can do?.. -- zverok
+      # For me, more resonable thing would be something like
+      #
+      # [
+      #   {"index" => "one"  , "a"=>1, "b"=>3, "c"=>6},
+      #   {"index" => "two"  , "a"=>2, "b"=>4, "c"=>7},
+      #   {"index" => "three", "a"=>3, "b"=>5, "c"=>8}
+      # ]
+      #
+      # Or maybe
+      #
+      # [
+      #   ["one"  , {"a"=>1, "b"=>3, "c"=>6}],
+      #   ["two"  , {"a"=>2, "b"=>4, "c"=>7}],
+      #   ["three", {"a"=>3, "b"=>5, "c"=>8}]
+      # ]
+      #
+      # Or even
+      #
+      # {
+      #   "one"   => {"a"=>1, "b"=>3, "c"=>6},
+      #   "two"   => {"a"=>2, "b"=>4, "c"=>7},
+      #   "three" => {"a"=>3, "b"=>5, "c"=>8}
+      # }
+      #
+      it { is_expected.to eq(
+        [
+          [
+            {"a"=>1, "b"=>3, "c"=>6},
+            {"a"=>2, "b"=>4, "c"=>7},
+            {"a"=>3, "b"=>5, "c"=>8}
+          ],
+          ["one", "two", "three"]
+        ]
+      )}
+    end
+
+    context 'without index' do
+      let(:json) { df.to_json(true) }
+
+      it { is_expected.to eq(
+        [
+          {"a"=>1, "b"=>3, "c"=>6},
+          {"a"=>2, "b"=>4, "c"=>7},
+          {"a"=>3, "b"=>5, "c"=>8}
+        ]
+      )}
+    end
+  end
+
+  describe "#to_h" do
+    subject { df.to_h }
+
+    it "converts to a hash" do
+      expect(subject).to eq(
+        {
+          a: DaruLite::Vector.new([1,2,3,4,5],
+            index: [:one, :two, :three, :four, :five]),
+          b: DaruLite::Vector.new([11,12,13,14,15],
+            index: [:one, :two, :three, :four, :five]),
+          c: DaruLite::Vector.new([11,22,33,44,55],
+            index: [:one, :two, :three, :four, :five])
+        }
+      )
+    end
+  end
+
+  describe '#to_s' do
+    subject { df.to_s }
+
+    it 'produces a class, size description' do
+      expect(subject).to eq "#<DaruLite::DataFrame(5x3)>"
+    end
+
+    it 'produces a class, name, size description' do
+      df.name = "Test"
+      expect(subject).to eq "#<DaruLite::DataFrame: Test(5x3)>"
+    end
+
+    it 'produces a class, name, size description when the name is a symbol' do
+      df.name = :Test
+      expect(subject).to eq "#<DaruLite::DataFrame: Test(5x3)>"
+    end
+  end
+end

data/spec/data_frame/duplicatable_example.rb

@@ -0,0 +1,111 @@
+shared_examples_for 'a duplicatable DataFrame' do
+  describe "#dup" do
+    context DaruLite::Index do
+      subject { df.dup }
+
+      it "dups every data structure inside DataFrame" do
+        expect(subject.object_id).not_to eq(df.object_id)
+        expect(subject.vectors.object_id).not_to eq(df.vectors.object_id)
+        expect(subject.index.object_id).not_to eq(df.index.object_id)
+
+        df.each_vector_with_index do |vector, index|
+          expect(vector.object_id).not_to eq(subject[index].object_id)
+          expect(vector.to_a.object_id).not_to eq(subject[index].to_a.object_id)
+        end
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      subject { df_mi.dup }
+
+      it "duplicates with multi index" do
+        expect(subject).to eq(df_mi)
+        expect(subject.vectors.object_id).not_to eq(df_mi.vectors.object_id)
+        expect(subject.index.object_id).not_to eq(df_mi.index.object_id)
+      end
+    end
+  end
+
+  describe "#clone_structure" do
+    subject { df.clone_structure }
+
+    it "clones only the index and vector structures of the data frame" do
+      expect(subject.vectors).to eq(df.vectors)
+      expect(subject.index).to eq(df.index)
+      expect(subject[:a]).to eq(DaruLite::Vector.new([nil] * subject[:a].size, index: df.index))
+    end
+  end
+
+  describe "#clone" do
+    subject { df.clone }
+
+    context 'no argument is passed' do
+      subject { df.clone }
+
+      it "returns a view of the whole dataframe" do
+        expect(df.object_id).to_not eq(subject.object_id)
+        expect(df[:a].object_id).to eq(subject[:a].object_id)
+        expect(df[:b].object_id).to eq(subject[:b].object_id)
+        expect(df[:c].object_id).to eq(subject[:c].object_id)
+      end
+    end
+
+    context 'vector names are passed' do
+      subject { df.clone(:a, :b) }
+
+      it "returns a view of selected vectors" do
+        expect(subject.object_id).to_not eq(df.object_id)
+        expect(subject[:a].object_id).to eq(df[:a].object_id)
+        expect(subject[:b].object_id).to eq(df[:b].object_id)
+      end
+    end
+
+    context 'array of vector names is passed' do
+      subject { df.clone([:a, :b]) }
+
+      it "clones properly when supplied array" do
+        expect(subject.object_id).to_not eq(df.object_id)
+        expect(subject[:a].object_id).to eq(df[:a].object_id)
+        expect(subject[:b].object_id).to eq(df[:b].object_id)
+      end
+    end
+
+    it "original dataframe remains unaffected when operations are applied on subject data frame" do
+      original = df.dup
+      subject.delete_vector :a
+
+      expect(df).to eq(original)
+    end
+  end
+
+  describe "#clone_only_valid" do
+    subject { df.clone_only_valid }
+
+    context 'df has missing values' do
+      let(:df) do
+        DaruLite::DataFrame.new({
+          a: [1  , 2, 3, nil, 4, nil, 5],
+          b: [nil, 2, 3, nil, 4, nil, 5],
+          c: [1,   2, 3, 43 , 4, nil, 5]
+        })
+      end
+
+      it 'clones only valid values' do
+        expect(subject).to eq(df.reject_values(*DaruLite::MISSING_VALUES))
+      end
+    end
+
+    context 'df has no missing values' do
+      let(:df) do
+        DaruLite::DataFrame.new({
+          a: [2,3,4,5],
+          c: [2,3,4,5]
+        })
+      end
+
+      it 'clones all values' do
+        expect(subject).to eq(df.clone)
+      end
+    end
+  end
+end