object_table 0.2.8 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzA3YzQ3OTc1OGZiMzYwN2NlNGM0Y2UxN2ExOTJjNjQxODdiZTdkNQ==
+    ZTUwZmM3Nzk5N2I3NmE4ZGYwZmE0M2IzMjBkZDEyZTk0NTcxNzliNQ==
   data.tar.gz: !binary |-
-    MzdhYWU4NmI2MWNhOGM2YTk4MzAwNGRiYTAyZDg1OWE4YWM2ZWZmNg==
+    ODg5Zjc3Nzk5ZGIyMjk1OWNjYjFlYzhjMzhlMGNlNzdjMGI3ZWE0OQ==
 SHA512:
   metadata.gz: !binary |-
-    MmU2MTA0NGY3NzA1ZGM3NDVlOWJiOTBmM2NiYWM3OTNkZjdiM2NhZTQzMDUz
-    Zjg5NzYwOWZmMzUyMzE3MWIyZjE2ZGEwNTRhZTI2ZjlhMjhkZDNhNzgyNWNj
-    N2Y0YWExNDQ5NzU2MGFjNzdhMmY1NWY1ZTYxOWVhNGU5YjliODc=
+    OWFlMzcwN2U2MTQ4Y2ZkNWQyY2I2Y2I1YWFkM2ZjMDIzNTgzYTAxOTNhZDVl
+    NmIxMDRkY2I0NjQ3NTAwZGYxYzU3MjRiZGFkMjU5ODg2ODdjNzBmMjEwNGNh
+    ZTRmODBiOWRiM2Y2Zjc5ZjY3OWYwZTk4YzgxY2UzZDdkY2YyMDI=
   data.tar.gz: !binary |-
-    YTZjYTFmMjljNGQzYjkzY2U1OTU5MTQ3ZjllMDkyMDBiYjgxYzE2NDk5NmE3
-    MDU2YWNhNTkzOGUzZTc2ZTk2MGIyYjUwOTIzZjI0NmI0M2RkNmRlNDZjMjAz
-    M2VkZWMzYWE4MDI3MmVkOWE5ZmRhZTg0ZWFlODEwMDllMGE5YjQ=
+    NjkwZWRiM2FlYmVhNjgyNzRhYmZmN2I1YzVhYzJjYTVlYzVlMDFmZTFiNGM0
+    NjcyMzdlYTIwMDM2MjljN2VkNmM2OTM1MzBjOWZiOWJiMTlhYmE5MWQxMTI2
+    YmQxMmYxNzQ2MjhjMTc4ZTk3ODhhYTcyZTM2OGE4ZjMwOTNkNDY=

data/README.md

@@ -79,12 +79,12 @@ You can get a column by using `#[]` or using the column name as a method.
 
 # using a method
 >>> data.a
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 1, 2, 3 ] 
 
 # ... or using []
 >>> data[:a]
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 1, 2, 3 ] 
 ```
 
@@ -140,24 +140,24 @@ IndexError: dst.shape[0]=3 != src.shape[0]=4
 >>> data = ObjectTable.new(col0: [0]*3)
 >>> data[:col1] = [1, 2, 3]
 >>> data.col1
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 1, 2, 3 ] 
 
 # this time, let's make it a float instead
 >>> data.set_column(:col2, [1, 2, 3], 'float')
 >>> data.col2
- => ObjectTable::Column.float(3): 
+ => NArray.float(3): 
 [ 1.0, 2.0, 3.0 ] 
 
 >>> data[:col3] = 4
 >>> data.col3
- => ObjectTable::Column.object(3): 
+ => NArray.object(3): 
 [ 4, 4, 4 ] 
 
 # this time, let's make it multi dimensional
 >>> data.set_column(:col4, 4, 'int', 5)
 >>> data.col4
- => ObjectTable::Column.int(5,3): 
+ => NArray.int(5,3): 
 [ [ 4, 4, 4, 4, 4 ], 
   [ 4, 4, 4, 4, 4 ], 
   [ 4, 4, 4, 4, 4 ] ] 
@@ -166,12 +166,12 @@ IndexError: dst.shape[0]=3 != src.shape[0]=4
 ### Operating on columns
 
 All standard NArray operations apply (addition, subtraction etc.)
-Missing methods are vectorised over the column
+Missing methods are vectorised over the column. (NOTE: this feature has been removed in v0.3.0)
 
 ```ruby
 >>> data = ObjectTable.new(column: ['abc', 'bcd', 'cde'])
 >>> data.column.match(/bc/)
- => ObjectTable::Column.object(3): 
+ => NArray.object(3): 
 [ #<MatchData "bc">, #<MatchData "bc">, nil ] 
 ```
 
@@ -184,7 +184,7 @@ This is just a convenience method.
 
 # this is exactly the same as (data.a + data.b)
 >>> data.apply{ a + b }
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 5, 7, 9 ] 
 
 # you can use self to set/add columns
@@ -199,7 +199,7 @@ This is just a convenience method.
 
 # if you don't want it to steal the binding (self), make the block take an argument
 >>> data.apply{|tbl| tbl.a + tbl.c }
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 5, 12, 21 ] 
 ```
 
@@ -468,7 +468,7 @@ The act of subclassing itself is easy, but any methods you add won't be availabl
 
 >>> data = BrokenTable.new(a: 1..3, b: 4..6)
 >>> data.a_plus_b
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 5, 7, 9 ] 
 
 # this won't work!
@@ -498,12 +498,12 @@ The easiest way is just to include a module with your common methods.
 
 >>> data = WorkingTable.new(a: 1..3, b: 4..6)
 >>> data.a_plus_b
- => ObjectTable::Column.int(3): 
+ => NArray.int(3): 
 [ 5, 7, 9 ] 
 
 # hurrah!
 >>> data.where{ a > 1 }.a_plus_b
- => ObjectTable::Column.int(2): 
+ => NArray.int(2): 
 [ 7, 9 ] 
 
 # also works in groups!

data/lib/object_table.rb

@@ -21,12 +21,12 @@ class ObjectTable
     @columns = columns
 
     @columns.each do |k, v|
-      @columns[k] = ObjectTable::Column.make(v)
+      @columns[k] = NArray.to_na(v)
     end
   end
 
   def add_column(name, typecode='object', *args)
-    col = ObjectTable::Column.new(typecode, *args, nrows)
+    col = NArray.new(typecode, *args, nrows)
     columns[name] = col
   end
 
@@ -55,7 +55,7 @@ class ObjectTable
     return self if new_values.values.first.empty?
 
     new_values.each do |k, v|
-      @columns[k] = @columns[k].stack(*v)
+      @columns[k] = ObjectTable::Column.stack(@columns[k], *v)
     end
     self
   end
@@ -123,20 +123,17 @@ class ObjectTable
     lblank = lindex.eq(-1)
     rblank = rindex.eq(-1)
 
-    left = left_cols.map do |k|
-      col = get_column(k)
-      padding = [nil] * (col.rank - 1)
-      col = col[*padding, lindex]
-      col[*padding, lblank] = [nil]
-      [k, col]
-    end
-
-    right = right_cols.map do |k|
-      col = other[k]
-      padding = [nil] * (col.rank - 1)
-      col = col[*padding, rindex]
-      col[*padding, rblank] = [nil]
-      [k, col]
+    data = [
+      [left_cols, lindex, lblank, self],
+      [right_cols, rindex, rblank, other],
+    ].flat_map do |cols, index, blanks, table|
+      cols.map do |k|
+        col = table.get_column(k)
+        padding = [nil] * (col.rank - 1)
+        col = col[*padding, index]
+        col[*padding, blanks] = [nil]
+        [k, col]
+      end
     end
 
     keys = []
@@ -150,7 +147,7 @@ class ObjectTable
       end
     end
 
-    self.class.new(keys + left + right)
+    self.class.new(keys + data)
   end
 
 

data/lib/object_table/column.rb

@@ -1,97 +1,16 @@
 require 'narray'
 
-class ObjectTable::Column < NArray
+module ObjectTable::Column
 
-  def self.make(value)
-    value = case value
-    when self
-      value
-    when NArray
-      if value.rank <= 0
-        self.new(value.typecode, 0)
-      else
-        cast(value)
-      end
-    when Range
-      to_na(value.to_a)
-    when Array
-      to_na(value)
-    else
-      raise ArgumentError.new("Expected NArray or Array, got #{value.class}")
-    end
-    value
-  end
-
-  def slice(*)
-    self.class.make super
-  end
-
-  def [](*a)
-    result = super
-    result.is_a?(NArray) ? self.class.make(result) : result
-  end
-
-  def []=(*args)
-    if (args[-1].is_a?(Array) or args[-1].is_a?(NArray)) and args[-1].empty? and self.empty?
-      return args[-1]
-    end
-
-    super
-  end
-
-  def to_object
-    to_type('object')
-  end
-
-  def to_bool
-    map{|i| i ? 1 : 0}.to_type('byte')
-  end
-
-  def uniq
-    self.class.make to_a.uniq
-  end
-
-  def coerce_rev(other, operator)
-    other.send(operator, NArray.refer(self))
-  end
-
-  def method_missing(*args)
-    collect{|x| x.send(*args)}
-  end
-
-#   def collect(*)
-#     self.class.make super, name
-#   end
-
-  def _refer(value)
-    value.is_a?(NArray) ? NArray.refer(value) : value
-  end
-
-  %w{ + - * / }.each do |op|
-    define_method(op) do |other|
-      #self.class.make super(_refer(other)), name
-      super(_refer(other))
-    end
-  end
-
-  %w{ xor or and <= >= le ge < > gt lt % ** ne eq & | ^ to_type }.each do |op|
-    define_method(op) do |other|
-      self.class.make super(other)
-    end
-  end
-
-#   %w{ not abs -@ ~ }.each do |op|
-#     define_method(op) do
-#       self.class.make super()
-# #     end
-#   end
+  def self.stack(*columns)
+    return NArray[] if columns.empty?
+    return columns[0].clone if columns.length == 1
 
-  def stack(*others)
-    columns = [self] + others
     new_rows = columns.map{|x| x.shape[-1]}.reduce(:+)
-    new_col = self.class.new(typecode, *shape[0...-1], new_rows)
+    first_col = columns.first
+    new_col = NArray.new(first_col.typecode, *first_col.shape[0...-1], new_rows)
 
-    padding = [nil] * (rank - 1)
+    padding = [nil] * (first_col.rank - 1)
 
     row = 0
     columns.each do |col|

data/lib/object_table/masked_column.rb

@@ -1,8 +1,10 @@
 require_relative 'column'
 
-class ObjectTable::MaskedColumn < ObjectTable::Column
+class ObjectTable::MaskedColumn < NArray
   attr_accessor :indices, :parent, :padded_dims
 
+  EMPTY = NArray[]
+
   def self.mask(parent, indices)
     if parent.rank > 1
       padded_dims = [nil] * (parent.rank - 1)
@@ -48,7 +50,12 @@ class ObjectTable::MaskedColumn < ObjectTable::Column
   end
 
   def clone
-    ObjectTable::Column.cast(self).clone
+    NArray.cast(self).clone
+  end
+
+  def coerce_rev(other, operator)
+    return other.send(operator, EMPTY) if empty?
+    other.send(operator, NArray.cast(self))
   end
 
 end

data/lib/object_table/table_methods.rb

@@ -38,6 +38,7 @@ module ObjectTable::TableMethods
     value = value.to_a if value.is_a?(Range)
 
     if column
+      return value if column.empty? and value.empty?
       return (column[] = value)
     end
 

data/lib/object_table/version.rb

@@ -1,3 +1,3 @@
 class ObjectTable
-  VERSION = "0.2.8"
+  VERSION = "0.3.0"
 end

data/spec/object_table/column_spec.rb

@@ -1,258 +1,41 @@
 require 'object_table/column'
 
-shared_examples 'a column coercer' do |value|
-  subject{ ObjectTable::Column.make(value) }
-
-  it "should convert #{value.class} into a column" do
-    expect(subject).to be_a ObjectTable::Column
-    expect(subject.to_a).to eql value.to_a
-  end
-end
-
-shared_examples 'a NArray' do |operator, options={}|
-  unary = options[:unary]
-
-  let(:x){ ObjectTable::Column.make(0..10) }
-  let(:y){ ObjectTable::Column.make(5..15) }
-
-  let(:x_na){ NArray.to_na((0..10).to_a) }
-  let(:y_na){ NArray.to_na((5..15).to_a) }
-
-  if unary
-    subject{ x.send(operator) }
-    let(:expected_result){ x_na.send(operator) }
-  else
-    subject{ x.send(operator, y) }
-    let(:expected_result){ x_na.send(operator, y_na) }
-  end
-
-  describe "#{operator}" do
-    it "should give the correct result" do
-      expect(subject).to eq expected_result
-    end
-
-    it 'should return a column' do
-      expect(subject).to be_a ObjectTable::Column
-    end
-  end
-end
-
-shared_examples 'NArray slicing' do |is_column, *args|
-  let(:x_na)            { NArray.to_na(x.to_a) }
-
-  %w{ [] slice }.each do |method|
-    describe "##{method}" do
-      let(:result)          { x.send(method, *args) }
-      let(:expected_result) { x_na.send(method, *args) }
-
-      it "should give the correct result" do
-        expect(result).to eq expected_result
-      end
-
-      if is_column
-        it 'should return a column' do
-          expect(result).to be_a ObjectTable::Column
-        end
-      end
-    end
-  end
-end
-
-
-shared_examples 'a vectorized operator' do |method|
-  it "should vectorize :#{method} over the array" do
-    expect(subject.send(method).to_a).to eql subject.to_a.map{|x| x.send(method)}
-  end
-end
-
 describe ObjectTable::Column do
 
-  describe '.make' do
-    subject{ ObjectTable::Column.make(value) }
-
-    context 'on a Column' do
-      let(:value){ ObjectTable::Column[1, 2, 3] }
-
-      it 'should return the same column' do
-        expect(subject).to be value
-      end
-    end
-
-    it_behaves_like "a column coercer", NArray[1, 2, 3]
-    it_behaves_like "a column coercer", 0...100
-    it_behaves_like "a column coercer", [1, 2, 3]
-
-    context 'on something unsupported' do
-      let(:value){ Object.new }
-
-      it 'should fail' do
-        expect{subject}.to raise_error
-      end
-    end
-
-  end
-
-  describe '#to_object' do
-    let(:column){ ObjectTable::Column[1, 2, 3] }
-
-    it 'should coerce the column into objects' do
-      expect(column.typecode).to eql NArray.int(0).typecode
-      expect(column.to_object.typecode).to eql NArray.object(0).typecode
-      expect(column.to_object).to eq column
-    end
-  end
-
-  describe '#to_bool' do
-    let(:column){ ObjectTable::Column.cast([true, false, nil, 'abcd', 1234], 'object') }
-
-    it 'should coerce the column into objects' do
-      expect(column.typecode).to eql NArray.object(0).typecode
-      expect(column.to_bool.typecode).to eql NArray.byte(0).typecode
-      expect(column.to_bool).to eq column.map{|i| i ? 1 : 0}
-    end
-  end
-
-  describe '#uniq' do
-    subject{ ObjectTable::Column.make([1, 1, 2, 2, 3, 1]) }
-
-    it 'should return a column of unique elements' do
-      expect(subject.uniq).to be_a ObjectTable::Column
-      expect(subject.uniq.to_a).to eql subject.to_a.uniq
-    end
-
-  end
-
-  describe 'vectorisation' do
-    subject{ ObjectTable::Column.make(Date.today ... (Date.today+100)) }
-
-    it_behaves_like 'a vectorized operator', 'day'
-    it_behaves_like 'a vectorized operator', 'month'
-    it_behaves_like 'a vectorized operator', 'year'
-  end
-
-  describe 'operations' do
-    it_behaves_like 'a NArray', '*'
-    it_behaves_like 'a NArray', '+'
-    it_behaves_like 'a NArray', '/'
-    it_behaves_like 'a NArray', '-'
-    it_behaves_like 'a NArray', '%'
-    it_behaves_like 'a NArray', '**'
-    it_behaves_like 'a NArray', '&'
-    it_behaves_like 'a NArray', '|'
-    it_behaves_like 'a NArray', '^'
-    it_behaves_like 'a NArray', 'eq'
-    it_behaves_like 'a NArray', 'ne'
-    it_behaves_like 'a NArray', 'gt'
-    it_behaves_like 'a NArray', '>'
-    it_behaves_like 'a NArray', 'ge'
-    it_behaves_like 'a NArray', '>='
-    it_behaves_like 'a NArray', 'lt'
-    it_behaves_like 'a NArray', '<'
-    it_behaves_like 'a NArray', 'le'
-    it_behaves_like 'a NArray', '<='
-    it_behaves_like 'a NArray', 'and'
-    it_behaves_like 'a NArray', 'or'
-    it_behaves_like 'a NArray', 'xor'
-    it_behaves_like 'a NArray', 'to_type'
-
-    it_behaves_like 'a NArray', '~', unary: true
-    it_behaves_like 'a NArray', '-@', unary: true
-    it_behaves_like 'a NArray', 'abs', unary: true
-    it_behaves_like 'a NArray', 'not', unary: true
-
-  end
-
-  describe 'slicing' do
-    let(:x){ ObjectTable::Column.float(10, 10, 10).random! }
-
-    it_behaves_like 'NArray slicing', false, 0
-    it_behaves_like 'NArray slicing', true, nil
-    it_behaves_like 'NArray slicing', false, 1, 2, 3
-    it_behaves_like 'NArray slicing', true, nil, nil, 5
-    it_behaves_like 'NArray slicing', true, nil, 5, 5
-    it_behaves_like 'NArray slicing', true, nil, true, false
-    it_behaves_like 'NArray slicing', true, [1, 2, 3, 4], nil, nil
-    it_behaves_like 'NArray slicing', true, [1, 2, 3, 4], nil, [1, 2]
-    it_behaves_like 'NArray slicing', true, 3...6
-    it_behaves_like 'NArray slicing', true, nil, nil, 3...6
-    it_behaves_like 'NArray slicing', true, 6...3, nil, 3...6
-    it_behaves_like 'NArray slicing', true, NArray[1..10] > 5, nil, nil
-  end
-
-  describe "#mask" do
-    let(:x)     { ObjectTable::Column.float(10, 10, 10).random! }
-    let(:mask)  { x < 0.5 }
-
-    let(:expected_result) { NArray.to_na(x.to_a)[mask] }
-
-    subject{ x.mask(mask) }
-
-    it "should give the correct result" do
-      expect(subject).to eq expected_result
-    end
-
-    it 'should return a column' do
-      expect(subject).to be_a ObjectTable::Column
-    end
-  end
-
-  context 'when empty' do
-    let(:col) { ObjectTable::Column.float(0) }
-
-    describe '#[]=' do
-      context 'on an empty array' do
-        subject{ col[] = [] }
-
-        it 'should work' do
-          expect{subject}.to_not raise_error
-        end
-      end
-
-      context 'on an empty narray' do
-        subject{ col[] = NArray[] }
-
-        it 'should work' do
-          expect{subject}.to_not raise_error
-        end
-      end
-
-      context 'on anything else' do
-        subject{ col[] = 3 }
-
-        it 'should not work' do
-          expect{subject}.to raise_error
-        end
-      end
-
-    end
-  end
-
-  describe '#stack' do
+  describe '.stack' do
     let(:columns) do
       [
-        ObjectTable::Column.float(10, 10).random!,
+        NArray.float(10, 10).random!,
         NArray.float(10, 30).random!,
-        ObjectTable::Column.to_na([[100] * 10] * 5),
+        NArray.to_na([[100] * 10] * 5),
       ]
     end
 
-    subject{ columns[0].stack(*columns[1..-1]) }
+    subject{ ObjectTable::Column.stack(*columns) }
 
-    it 'should return a column in the correct format' do
-      expect(subject).to be_a ObjectTable::Column
+    it 'should return a narray in the correct format' do
+      expect(subject).to be_a NArray
       expect(subject.typecode).to eql columns[0].typecode
     end
 
-    it 'should return a column with the correct size' do
+    it 'should return a narray with the correct size' do
       expect(subject.shape[0...-1]).to eql columns[0].shape[0...-1]
       expect(subject.shape[-1]).to eql (10 + 30 + 5)
     end
 
-    it 'should stack the columns' do
+    it 'should stack the narrays' do
       expect(subject[nil, 0...10]).to eq columns[0]
       expect(subject[nil, 10...40]).to eq columns[1]
       expect(subject[nil, 40...45]).to eq columns[2]
     end
+
+    context 'with no arguments' do
+      let(:columns) { [] }
+
+      it 'should return an empty NArray' do
+        expect(subject).to eq NArray[]
+      end
+    end
   end
 
-end
+end

data/spec/object_table/grouped_spec.rb

@@ -156,7 +156,7 @@ describe ObjectTable::Grouped do
       correct_keys = []
       grouped.each do
         keys << [@K[:parity]]
-        correct_keys << (self.col1 % 2).uniq.to_a
+        correct_keys << (self.col1 % 2).to_a.uniq
       end
 
       expect(keys).to match_array(correct_keys)

data/spec/object_table/masked_column_spec.rb

@@ -1,8 +1,42 @@
 require 'object_table/masked_column'
 
+shared_examples 'a NArray' do |operator, options={}|
+  unary = options[:unary]
+
+  let(:indices) { NArray[1, 3, 4, 6] }
+
+  let(:x){ ObjectTable::MaskedColumn.mask(x_na, indices) }
+  let(:y){ ObjectTable::MaskedColumn.mask(y_na, indices) }
+
+  let(:x_na){ NArray.to_na((0..10).to_a) }
+  let(:y_na){ NArray.to_na((5..15).to_a) }
+
+  if unary
+    subject{ x.send(operator) }
+    let(:expected_result){ x_na[indices].send(operator) }
+  else
+    subject{ x.send(operator, y) }
+    let(:expected_result){ x_na.send(operator, y_na)[indices] }
+  end
+
+  describe "#{operator}" do
+    it "should give the correct result" do
+      expect(subject).to eq expected_result
+    end
+
+    context 'with empty indices' do
+      let(:indices) { [] }
+
+      it "should give the correct result" do
+        expect(subject).to eq expected_result
+      end
+    end
+  end
+end
+
 describe ObjectTable::MaskedColumn do
 
-  let(:parent)    { ObjectTable::Column.float(10).random! }
+  let(:parent)    { NArray.float(10).random! }
   let(:indices)   { NArray[1, 3, 4, 6] }
   let(:other_indices) { NArray.to_na((0...parent.length).to_a - indices.to_a) }
   let(:masked)    { ObjectTable::MaskedColumn.mask(parent, indices) }
@@ -118,7 +152,7 @@ describe ObjectTable::MaskedColumn do
   end
 
   context 'with complex numbers' do
-    let(:parent)    { ObjectTable::Column.complex(10).indgen! }
+    let(:parent)    { NArray.complex(10).indgen! }
 
     include_examples 'destructive methods', 'imag=', 56
     include_examples 'destructive methods', 'conj!'
@@ -127,8 +161,8 @@ describe ObjectTable::MaskedColumn do
   describe '#clone' do
     let(:clone){ subject.clone }
 
-    it 'returns a Column' do
-      expect(clone).to be_an_instance_of ObjectTable::Column
+    it 'returns a NArray' do
+      expect(clone).to be_an_instance_of NArray
       expect(clone).to_not be_an_instance_of ObjectTable::MaskedColumn
     end
 
@@ -137,4 +171,36 @@ describe ObjectTable::MaskedColumn do
     end
   end
 
+  describe 'operations' do
+    it_behaves_like 'a NArray', '*'
+    it_behaves_like 'a NArray', '+'
+    it_behaves_like 'a NArray', '/'
+    it_behaves_like 'a NArray', '-'
+    it_behaves_like 'a NArray', '%'
+    it_behaves_like 'a NArray', '**'
+    it_behaves_like 'a NArray', '&'
+    it_behaves_like 'a NArray', '|'
+    it_behaves_like 'a NArray', '^'
+    it_behaves_like 'a NArray', 'eq'
+    it_behaves_like 'a NArray', 'ne'
+    it_behaves_like 'a NArray', 'gt'
+    it_behaves_like 'a NArray', '>'
+    it_behaves_like 'a NArray', 'ge'
+    it_behaves_like 'a NArray', '>='
+    it_behaves_like 'a NArray', 'lt'
+    it_behaves_like 'a NArray', '<'
+    it_behaves_like 'a NArray', 'le'
+    it_behaves_like 'a NArray', '<='
+    it_behaves_like 'a NArray', 'and'
+    it_behaves_like 'a NArray', 'or'
+    it_behaves_like 'a NArray', 'xor'
+    it_behaves_like 'a NArray', 'to_type'
+
+    it_behaves_like 'a NArray', '~', unary: true
+    it_behaves_like 'a NArray', '-@', unary: true
+    it_behaves_like 'a NArray', 'abs', unary: true
+    it_behaves_like 'a NArray', 'not', unary: true
+  end
+
+
 end

data/spec/object_table_spec.rb

@@ -9,9 +9,9 @@ describe ObjectTable do
     let(:columns){ {col1: [1, 2, 3], col2: NArray[4, 5, 6], col3: 7..9, col4: 10} }
     subject{ ObjectTable.new columns }
 
-    it 'should convert all columns into ObjectTable::Columns' do
+    it 'should convert all columns into NArrays' do
       subject.columns.values.each do |v|
-        expect(v).to be_a ObjectTable::Column
+        expect(v).to be_a NArray
       end
     end
 
@@ -25,11 +25,11 @@ describe ObjectTable do
     end
 
     context 'with multi dimensional columns' do
-      let(:columns){ {col1: [1, 2, 3], col2: NArray[[4, 4], [5, 5], [6, 6]]} }
+      let(:columns){ {col1: [1, 2, 3], col2: [[4, 4], [5, 5], [6, 6]]} }
 
-      it 'should convert all columns into ObjectTable::Columns' do
+      it 'should convert all columns into NArrays' do
         subject.columns.values.each do |v|
-          expect(v).to be_a ObjectTable::Column
+          expect(v).to be_a NArray
         end
       end
 
@@ -43,7 +43,7 @@ describe ObjectTable do
       end
 
       it 'should preserve the dimensions' do
-        expect(subject[:col2].shape).to eql columns[:col2].shape
+        expect(subject[:col2].shape).to eql NArray.to_na(columns[:col2]).shape
       end
     end
 
@@ -81,9 +81,9 @@ describe ObjectTable do
       expect(table.columns[column].to_a).to eql value
     end
 
-    it 'should coerce the value to a column' do
+    it 'should coerce the value to a narray' do
       subject
-      expect(table.columns[column]).to be_a ObjectTable::Column
+      expect(table.columns[column]).to be_a NArray
     end
 
     context 'with the wrong length' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_table
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Cheney Lin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-07 00:00:00.000000000 Z
+date: 2015-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray