daru 0.1.4.1 → 0.1.5

data/lib/daru/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = '0.1.4.1'.freeze
+  VERSION = '0.1.5'.freeze
 end

data/spec/accessors/array_wrapper_spec.rb

@@ -0,0 +1,3 @@
+describe Daru::Accessors::ArrayWrapper do
+  # TODO:
+end

data/spec/accessors/{wrappers_spec.rb → gsl_wrapper_spec.rb}

@@ -1,38 +1,3 @@
-describe Daru::Accessors::NMatrixWrapper do
-  before :each do
-    stub_context = Object.new
-    @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
-  end
-
-  it "checks for actual NMatrix creation" do
-    expect(@nm_wrapper.data.class).to eq(NMatrix)
-  end
-
-  it "checks the actual size of the NMatrix object" do
-    expect(@nm_wrapper.data.size).to eq(10)
-  end
-
-  it "checks that @size is the number of elements in the vector" do
-    expect(@nm_wrapper.size).to eq(5)
-  end
-
-  it "checks for underlying NMatrix data type" do
-    expect(@nm_wrapper.data.dtype).to eq(:float32)
-  end
-
-  it "resizes" do
-    @nm_wrapper.resize(100)
-
-    expect(@nm_wrapper.size).to eq(5)
-    expect(@nm_wrapper.data.size).to eq(100)
-    expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
-  end
-end
-
-describe Daru::Accessors::ArrayWrapper do
-
-end
-
 describe Daru::Accessors::GSLWrapper do
   before :each do
     @stub_context = Object.new

data/spec/accessors/nmatrix_wrapper_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper.rb'
+
+describe Daru::Accessors::NMatrixWrapper do
+  before :each do
+    stub_context = Object.new
+    @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
+  end
+
+  it "checks for actual NMatrix creation" do
+    expect(@nm_wrapper.data.class).to eq(NMatrix)
+  end
+
+  it "checks the actual size of the NMatrix object" do
+    expect(@nm_wrapper.data.size).to eq(10)
+  end
+
+  it "checks that @size is the number of elements in the vector" do
+    expect(@nm_wrapper.size).to eq(5)
+  end
+
+  it "checks for underlying NMatrix data type" do
+    expect(@nm_wrapper.data.dtype).to eq(:float32)
+  end
+
+  it "resizes" do
+    @nm_wrapper.resize(100)
+
+    expect(@nm_wrapper.size).to eq(5)
+    expect(@nm_wrapper.data.size).to eq(100)
+    expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
+  end
+end

data/spec/{categorical_spec.rb → category_spec.rb}

@@ -305,6 +305,9 @@ describe Daru::Vector, "categorical" do
       its(:'index.to_a') { is_expected.to eq [:a, :b, :c, :d, 1] }
       its(:to_a) { is_expected.to eq [0.4, 0, 0.2, 0, 0.4] }
     end
+    context "invalid argument" do
+      it { expect { dv.frequencies :hash }.to raise_error ArgumentError  }
+    end
   end
 
   context "#to_category" do

data/spec/core/group_by_spec.rb

@@ -5,7 +5,7 @@ describe Daru::Core::GroupBy do
       b: %w{one one two three two two one three},
       c:   [1  ,2   ,3  ,1     ,3   ,6  ,3  ,8],
       d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
-    })
+    }, order: [:a, :b, :c, :d])
 
     @sl_group = @df.group_by(:a)
     @dl_group = @df.group_by([:a, :b])
@@ -402,4 +402,20 @@ describe Daru::Core::GroupBy do
         Daru::Vector.new(['one', 'three', 'two', 'oneone', 'three', 'twotwo'], index: @dl_multi_index)
     end
   end
+
+  context 'groups by first vector if no vector mentioned' do
+    subject { @df.group_by }
+
+    it { is_expected.to be_a Daru::Core::GroupBy }
+    its(:groups) { is_expected.to eq @sl_group.groups }
+    its(:size) { is_expected.to eq @sl_group.size }
+  end
+
+  context 'group and sum with numeric indices' do
+    let(:df) { Daru::DataFrame.new({ g: ['a','a','a'], num: [1,2,3]}, index: [2,12,23]) }
+
+    subject { df.group_by([:g]).sum }
+
+    it { is_expected.to eq Daru::DataFrame.new({num: [6]}, index: ['a']) }
+  end
 end

data/spec/core/merge_spec.rb

@@ -37,6 +37,18 @@ describe Daru::DataFrame do
       expect(@left.join(@right_many, how: :inner, on: [:id])).to eq(answer)
     end
 
+    it "performs an inner join of two dataframes that has many to one mapping" do
+      left_many = @right_many
+      right = @left
+
+      answer = Daru::DataFrame.new({
+        :name_2 => ['Pirate', 'Pirate', 'Pirate', 'Pirate'],
+        :id => [1,1,1,1],
+        :name_1 => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      }, order: [:name_1, :id, :name_2])
+      expect(left_many.join(right, how: :inner, on: [:id])).to eq(answer)
+    end
+
     it "performs an inner join of two dataframes that has many to many mapping" do
       @left[:id].recode! { |v| v == 2 ? 1 : v }
       answer = Daru::DataFrame.new({
@@ -56,6 +68,18 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
     end
 
+    it "adds a left/right indicator" do
+      answer = Daru::DataFrame.new({
+        :id_1 => [nil,2,3,1,nil,4],
+        :name => ["Darth Vader", "Monkey", "Ninja", "Pirate", "Rutabaga", "Spaghetti"],
+        :id_2 => [3,nil,4,2,1,nil]
+      }, order: [:id_1, :name, :id_2])
+
+      outer = @left.join(@right, how: :outer, on: [:name], indicator: :my_indicator)
+      expect(outer[:my_indicator].to_a).to eq [:right_only, :left_only, :both, :both, :right_only, :left_only]
+    end
+
+
     it "performs a full outer join when the right join keys have nils" do
       @right[:name].recode! { |v| v == 'Rutabaga' ? nil : v }
       answer = Daru::DataFrame.new({
@@ -117,8 +141,21 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :right, on: [:name])).to eq(answer)
     end
 
+    it "doesn't convert false into nil when joining boolean values" do
+      left = Daru::DataFrame.new({ key: [1,2,3], left_value: [true, false, true] })
+      right = Daru::DataFrame.new({ key: [1,2,3], right_value: [true, false, true] })
+
+      answer = Daru::DataFrame.new({
+        left_value: [true, false, true],
+        key: [1,2,3],
+        right_value: [true, false, true]
+      }, order: [:left_value, :key, :right_value] )
+
+      expect(left.join(right, on: [:key], how: :inner)).to eq answer
+    end
+
     it "raises if :on field are absent in one of dataframes" do
-      @right.vectors = [:id, :other_name]
+      @right.vectors = Daru::Index.new [:id, :other_name]
       expect { @left.join(@right, how: :right, on: [:name]) }.to \
         raise_error(ArgumentError, /Both dataframes expected .* :name/)
 

data/spec/core/query_spec.rb

@@ -266,6 +266,11 @@ describe "Arel-like syntax" do
           @df.where (@df[:names].eq('james') | @df[:sym].eq(:four))
           ).to eq(answer)
       end
+
+      it "does not give SystemStackError" do
+        v = Daru::Vector.new [1]*300_000
+        expect { v.where v.eq(1) }.not_to raise_error
+      end
     end
 
     context Daru::Vector do

data/spec/dataframe_spec.rb

@@ -55,6 +55,13 @@ describe Daru::DataFrame do
         expect(df[:a]) .to eq(Daru::Vector.new [1,1,1,1])
       end
 
+      it "creates empty dataframe" do
+        df = Daru::DataFrame.rows [], order: [:a, :b, :c]
+
+        expect(df.vectors).to eq(Daru::Index.new [:a,:b,:c])
+        expect(df.index).to be_empty
+      end
+
       it "creates a DataFrame from Vector rows" do
         rows = @rows.map { |r| Daru::Vector.new r, index: [:a,:b,:c,:d,:e] }
 
@@ -170,14 +177,14 @@ describe Daru::DataFrame do
       end
 
       it "initializes from an Array of Hashes" do
-        df = Daru::DataFrame.new([{a: 1, b: 11}, {a: 2, b: 12}, {a: 3, b: 13},
+        df = Daru::DataFrame.new([{a: 1, b: 11}, {a: false, b: 12}, {a: 3, b: 13},
           {a: 4, b: 14}, {a: 5, b: 15}], order: [:b, :a],
           index: [:one, :two, :three, :four, :five])
 
         expect(df.index)  .to eq(Daru::Index.new [:one, :two, :three, :four, :five])
         expect(df.vectors).to eq(Daru::Index.new [:b, :a])
         expect(df.a.class).to eq(Daru::Vector)
-        expect(df.a)      .to eq([1,2,3,4,5].dv(:a,[:one, :two, :three, :four, :five]))
+        expect(df.a)      .to eq([1,false,3,4,5].dv(:a,[:one, :two, :three, :four, :five]))
       end
 
       it "initializes from Array of Arrays" do
@@ -612,48 +619,63 @@ describe Daru::DataFrame do
   end
 
   context '#method_missing' do
-    subject(:data_frame) {
-      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
-        c: [11,22,33,44,55]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-    }
+    let(:df) { Daru::DataFrame.new({
+      :a  => [1, 2, 3, 4, 5],
+      'b' => [5, 4, 3, 2, 1]
+    }, index: 11..15)}
 
-    context 'getting the vector' do
-      subject{
-        data_frame.a
-      }
-      it { is_expected.to eq [1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]) }
+    context 'get vector' do
+      context 'by string' do
+        subject { df.b }
+
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [5, 4, 3, 2, 1] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+
+      context 'by symbol' do
+        subject { df.a }
+
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
     end
 
-    context 'setting existing vector' do
-      before{
-        data_frame.a = [100,200,300,400,500]
-      }
-      it { is_expected.to eq(Daru::DataFrame.new({
-            b: [11,12,13,14,15],
-            a: [100,200,300,400,500],
-            c: [11,22,33,44,55]}, order: [:a, :b, :c],
-            index: [:one, :two, :three, :four, :five]))
-      }
+    context 'set existing vector' do
+      context 'by string' do
+        before { df.b = [:a, :b, :c, :d, :e] }
+        subject { df }
+
+        it { is_expected.to be_a Daru::DataFrame }
+        its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
+        its(:'b.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+
+      context 'by symbol' do
+        before { df.a = [:a, :b, :c, :d, :e] }
+        subject { df }
+
+        it { is_expected.to be_a Daru::DataFrame }
+        its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
+        its(:'a.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
     end
 
-    context 'setting new vector' do
-      before{
-        data_frame.d = [100,200,300,400,500]
-      }
-      it { is_expected.to eq(Daru::DataFrame.new({
-            b: [11,12,13,14,15],
-            a: [1,2,3,4,5],
-            d: [100,200,300,400,500],
-            c: [11,22,33,44,55]}, order: [:a, :b, :c, :d],
-            index: [:one, :two, :three, :four, :five]))
-      }
+    context 'set new vector' do
+      before { df.c = [5, 5, 5, 5, 5] }
+      subject { df }
+
+      it { is_expected.to be_a Daru::DataFrame }
+      its(:'vectors.to_a') { is_expected.to eq [:a, 'b', :c] }
+      its(:'c.to_a') { is_expected.to eq [5, 5, 5, 5, 5] }
+      its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
     end
 
-    context 'no vector found' do
-      it 'should raise' do
-        expect { data_frame.e }.to raise_error(NoMethodError)
-      end
+    context 'reference invalid vector' do
+      it { expect { df.d }.to raise_error NoMethodError }
     end
   end
 
@@ -1370,6 +1392,15 @@ describe Daru::DataFrame do
           c: [11,22,33,44,55]}, order: [:a, :b, :c])
 
         expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+        expect(df.row[3]).to eq([4,14,44].dv(nil, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index for numerical index DataFrame" do
+        df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+          c: [11,22,33,44,55]}, order: [:a, :b, :c], index: [1,2,3,4,5])
+
+        expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+        expect(df.row[3]).to eq([3,13,33].dv(nil, [:a, :b, :c]))
       end
     end
 
@@ -1616,7 +1647,7 @@ describe Daru::DataFrame do
       }, index: 11..18)
     end
     before { df.to_category :b }
-    
+
     context 'remove nils only' do
       subject { df.reject_values nil }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1626,7 +1657,7 @@ describe Daru::DataFrame do
       its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 7] }
       its(:'index.to_a') { is_expected.to eq [11, 12, 18] }
     end
-    
+
     context 'remove Float::NAN only' do
       subject { df.reject_values Float::NAN }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1636,7 +1667,7 @@ describe Daru::DataFrame do
       its(:'c.to_a') { is_expected.to eq ['a', 3, 5, nil, 7] }
       its(:'index.to_a') { is_expected.to eq [11, 13, 16, 17, 18] }
     end
-    
+
     context 'remove both nil and Float::NAN' do
       subject { df.reject_values nil, Float::NAN }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1646,7 +1677,7 @@ describe Daru::DataFrame do
       its(:'c.to_a') { is_expected.to eq ['a', 7] }
       its(:'index.to_a') { is_expected.to eq [11, 18] }
     end
-    
+
     context 'any other values' do
       subject { df.reject_values 1, 5 }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1664,9 +1695,9 @@ describe Daru::DataFrame do
       its(:'a.to_a') { is_expected.to eq [7] }
       its(:'b.to_a') { is_expected.to eq [8] }
       its(:'c.to_a') { is_expected.to eq [7] }
-      its(:'index.to_a') { is_expected.to eq [18] }      
+      its(:'index.to_a') { is_expected.to eq [18] }
     end
-    
+
     context 'when resultant dataframe is empty' do
       subject { df.reject_values 1, 2, 3, 4, 5, 6, 7, nil, Float::NAN }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1674,10 +1705,10 @@ describe Daru::DataFrame do
       its(:'a.to_a') { is_expected.to eq [] }
       its(:'b.to_a') { is_expected.to eq [] }
       its(:'c.to_a') { is_expected.to eq [] }
-      its(:'index.to_a') { is_expected.to eq [] }          
+      its(:'index.to_a') { is_expected.to eq [] }
     end
   end
-  
+
   context '#replace_values' do
     subject do
       Daru::DataFrame.new({
@@ -1687,7 +1718,7 @@ describe Daru::DataFrame do
       })
     end
     before { subject.to_category :b }
-    
+
     context 'replace nils only' do
       before { subject.replace_values nil, 10 }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1696,7 +1727,7 @@ describe Daru::DataFrame do
       its(:'b.to_a') { is_expected.to eq [:a,  :b, 10, Float::NAN, 10, 3, 5, 8] }
       its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 3, 4, 3, 5, 10, 7] }
     end
-    
+
     context 'replace Float::NAN only' do
       before { subject.replace_values Float::NAN, 10 }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1705,7 +1736,7 @@ describe Daru::DataFrame do
       its(:'b.to_a') { is_expected.to eq [:a,  :b, nil, 10, nil, 3, 5, 8] }
       its(:'c.to_a') { is_expected.to eq ['a', 10, 3, 4, 3, 5, nil, 7] }
     end
-    
+
     context 'replace both nil and Float::NAN' do
       before { subject.replace_values [nil, Float::NAN], 10 }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1714,7 +1745,7 @@ describe Daru::DataFrame do
       its(:'b.to_a') { is_expected.to eq [:a,  :b, 10, 10, 10, 3, 5, 8] }
       its(:'c.to_a') { is_expected.to eq ['a', 10, 3, 4, 3, 5, 10, 7] }
     end
-    
+
     context 'replace other values' do
       before { subject.replace_values [1, 5], 10 }
       it { is_expected.to be_a Daru::DataFrame }
@@ -1722,7 +1753,7 @@ describe Daru::DataFrame do
       its(:'a.to_a') { is_expected.to eq [10, 2, 3, nil, Float::NAN, nil, 10, 7] }
       its(:'b.to_a') { is_expected.to eq [:a,  :b, nil, Float::NAN, nil, 3, 10, 8] }
       its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 3, 4, 3, 10, nil, 7] }
-    end    
+    end
   end
 
   context "#clone" do
@@ -2124,14 +2155,28 @@ describe Daru::DataFrame do
 
   context "#filter_rows" do
     context Daru::Index do
-      it "filters rows" do
-        df = Daru::DataFrame.new({a: [1,2,3], b: [2,3,4]})
+      context "when specified no index" do
+        it "filters rows" do
+          df = Daru::DataFrame.new({a: [1,2,3], b: [2,3,4]})
 
-        a = df.filter_rows do |row|
-          row[:a] % 2 == 0
+          a = df.filter_rows do |row|
+            row[:a] % 2 == 0
+          end
+
+          expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [1]))
         end
+      end
 
-        expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [1]))
+      context "when specified numerical index" do
+        it "filters rows" do
+          df = Daru::DataFrame.new({a: [1,2,3], b: [2,3,4]}, index: [1,2,3])
+
+          a = df.filter_rows do |row|
+            row[:a] % 2 == 0
+          end
+
+          expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [2]))
+        end
       end
 
       it "preserves names of vectors" do
@@ -2500,6 +2545,32 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#order=' do
+    let(:df) do
+      Daru::DataFrame.new({
+        a: [1, 2, 3],
+        b: [4, 5, 6]
+      }, order: [:a, :b])
+    end
+
+    context 'correct order' do
+      before { df.order = [:b, :a] }
+      subject { df }
+
+      its(:'vectors.to_a') { is_expected.to eq [:b, :a] }
+      its(:'b.to_a') { is_expected.to eq [4, 5, 6] }
+      its(:'a.to_a') { is_expected.to eq [1, 2, 3] }
+    end
+
+    context 'insufficient vectors' do
+      it { expect { df.order = [:a] }.to raise_error }
+    end
+
+    context 'wrong vectors' do
+      it { expect { df.order = [:a, :b, 'b'] }.to raise_error }
+    end
+  end
+
   context "#vectors=" do
     before :each do
       @df = Daru::DataFrame.new({
@@ -2523,6 +2594,13 @@ describe Daru::DataFrame do
         @df.vectors = Daru::Index.new([1,2,'3',4,'5'])
       }.to raise_error(ArgumentError)
     end
+
+    it "change name of vectors in @data" do
+      new_index_array = [:k, :l, :m]
+      @df.vectors = Daru::Index.new(new_index_array)
+
+      expect(@df.data.map { |vector| vector.name }).to eq(new_index_array)
+    end
   end
 
   context "#rename_vectors" do
@@ -2912,6 +2990,43 @@ describe Daru::DataFrame do
         )
       )
     end
+
+    it 'performs date pivoting' do
+      categories = %i[jan feb mar apr may jun jul aug sep oct nov dec]
+      df = Daru::DataFrame.rows([
+        [2014, 2, 1600.0, 20.0],
+        [2014, 3, 1680.0, 21.0],
+        [2016, 2, 1600.0, 20.0],
+        [2016, 4, 1520.0, 19.0],
+      ], order: [:year, :month, :visitors, :days])
+      df[:averages] = df[:visitors] / df[:days]
+      df[:month] = df[:month].map{|i| categories[i - 1]}
+      actual = df.pivot_table(index: :month, vectors: [:year], values: :averages)
+
+      # NB: As you can see, there are some "illogical" parts:
+      #     months are sorted lexicographically, then made into multi-index
+      #     with one-element-per-tuple, then order of columns is dependent
+      #     on which month is lexicographically first (its apr, so, apr-2016
+      #     is first row to gather, so 2016 is first column).
+      #
+      #     All of it is descendance of our group_by implementation (which
+      #     always sorts results & always make array keys). I hope that fixing
+      #     group_by, even to the extend described at https://github.com/v0dro/daru/issues/152,
+      #     will be fix this case also.
+      expected =
+        Daru::DataFrame.new(
+          [
+            [80.0, 80.0, nil],
+            [nil, 80.0, 80.0],
+          ], index: Daru::MultiIndex.from_tuples([[:apr], [:feb], [:mar]]),
+          order: Daru::MultiIndex.from_tuples([[:averages, 2016], [:averages, 2014]])
+        )
+      # Comparing their parts previous to full comparison allows to
+      # find complicated differences.
+      expect(actual.vectors).to eq expected.vectors
+      expect(actual.index).to eq expected.index
+      expect(actual).to eq expected
+    end
   end
 
   context "#shape" do
@@ -3059,14 +3174,14 @@ describe Daru::DataFrame do
       })
     end
     before { df.to_category :b }
-    
+
     context 'true' do
       it { expect(df.include_values? nil).to eq true }
       it { expect(df.include_values? Float::NAN).to eq true }
       it { expect(df.include_values? nil, Float::NAN).to eq true }
       it { expect(df.include_values? 1, 30).to eq true }
     end
-    
+
     context 'false' do
       it { expect(df[:a, :c].include_values? nil).to eq false }
       it { expect(df[:c, :d].include_values? Float::NAN).to eq false }
@@ -3472,6 +3587,64 @@ describe Daru::DataFrame do
 
   end
 
+  context "#union" do
+    before do
+      @df1 = Daru::DataFrame.new({
+        a: [1, 2, 3],
+        b: [1, 2, 3]},
+        index: [1,3,5] )
+
+      @df2 = Daru::DataFrame.new({
+        a: [4, 5, 6],
+        c: [4, 5, 6]},
+        index: [7,9,11])
+
+      @df3 = Daru::DataFrame.new({
+        a: [4, 5, 6],
+        c: [4, 5, 6]},
+        index: [5,7,9])
+    end
+
+    it 'does not modify the original dataframes' do
+      df1_a = @df1[:a].to_a.dup
+      df2_a = @df2[:a].to_a.dup
+
+      _ = @df1.union @df2
+      expect(@df1[:a].to_a).to eq df1_a
+      expect(@df2[:a].to_a).to eq df2_a
+    end
+
+    it 'creates a new dataframe that is a concatenation of the two dataframe arguments' do
+      df1_a = @df1[:a].to_a.dup
+      df2_a = @df2[:a].to_a.dup
+
+      df_union = @df1.union @df2
+      expect(df_union[:a].to_a).to eq df1_a + df2_a
+    end
+
+    it 'fills in missing vectors with nils' do
+      df1_b = @df1[:b].to_a.dup
+      df2_c = @df2[:c].to_a.dup
+
+      df_union = @df1.union @df2
+      expect(df_union[:b].to_a).to eq df1_b + [nil] * @df2.size
+      expect(df_union[:c].to_a).to eq [nil] * @df1.size + df2_c
+    end
+
+    it 'overwrites part of the first dataframe if there are double indices' do
+      vec = Daru::Vector.new({a: 4, b: nil, c: 4})
+      expect(@df1.union(@df3).row[5]).to eq vec
+    end
+
+    it 'concats the indices' do
+      v1 = @df1.index.to_a
+      v2 = @df2.index.to_a
+
+      df_union = @df1.union @df2
+      expect(df_union.index.to_a).to eq v1 + v2
+    end
+  end
+  
   context '#inspect' do
     subject { df.inspect }