object_table 0.1.0

data/lib/object_table/table_methods.rb

@@ -0,0 +1,146 @@
+require 'forwardable'
+
+module ObjectTable::TableMethods
+  extend Forwardable
+
+  attr_reader :R
+  def initialize
+    @R = ObjectTable::BasicGrid
+  end
+
+  def ==(other)
+    return false unless other.is_a?(ObjectTable::TableMethods)
+    return columns == other.columns
+  end
+  alias_method :eql?, :==
+
+  def colnames
+    columns.keys
+  end
+
+  def nrows
+    columns.empty? ? 0 : columns.values.first.shape[-1]
+  end
+
+  def ncols
+    columns.keys.length
+  end
+
+  def_delegator :columns, :include?, :has_column?
+
+  def_delegator :columns, :[], :get_column
+  alias_method :[], :get_column
+
+  def set_column(name, value, *args)
+    column = get_column(name)
+    value = value.to_a if value.is_a?(Range)
+
+    if column
+      return (column[] = value)
+    end
+
+    if (value.is_a?(Array) or value.is_a?(NArray)) and args.empty?
+      value =  NArray.to_na(value)
+      unless value.shape[-1] == nrows
+        raise ArgumentError.new("Expected size of last dimension to be #{nrows}, was #{value.shape[-1]}")
+      end
+
+      args = [value.typecode] + value.shape[0...-1]
+    end
+
+    column = add_column(name, *args)
+    begin
+      column[] = value
+    rescue Exception => e
+      pop_column(name)
+      raise e
+    end
+  end
+  alias_method :[]=, :set_column
+
+  def pop_column(name)
+    columns.delete name
+  end
+
+  def apply(&block)
+    result = instance_eval &block
+    if result.is_a? ObjectTable::BasicGrid
+      result = ObjectTable.new(result)
+    end
+    result
+  end
+
+  def where(&block)
+    ObjectTable::TempView.new(self, &block)
+  end
+
+  def group(*args, &block)
+    ObjectTable::TempGrouped.new(self, *args, &block)
+  end
+
+  def sort_by(*keys)
+    sort_index = _get_sort_index(keys)
+    cols = ObjectTable::BasicGrid[columns.map{|k, v| [k, v[sort_index]]}]
+    ObjectTable.new(cols)
+  end
+
+  def method_missing(meth, *args, &block)
+    get_column(meth) or super
+  end
+
+  def respond_to?(meth)
+    super or has_column?(meth)
+  end
+
+  def inspect(max_section = 5)
+    header = "#{self.class}(#{nrows}, #{ncols})\n"
+    printed_columns = []
+
+    if nrows > max_section * 2
+      head = (0...max_section)
+      tail = ((nrows - max_section)...nrows)
+
+      printed_columns.push [''] + (head.to_a + tail.to_a).map{|i| "#{i}: "} + ['']
+      printed_columns += columns.map do |name, c|
+        c = c.get_rows([head, tail], true)
+        strings = c.shape[-1].times.map do |i|
+          row = c.get_rows(i)
+          row.is_a?(NArray) ? row.inspect.partition("\n")[-1].strip : row.inspect
+        end
+
+        [name.to_s] + strings + [name.to_s]
+      end
+    else
+      max_section = -1
+      printed_columns.push [''] + (0...nrows).map{|i| "#{i}: "} + ['']
+      printed_columns += columns.map do |name, c|
+        [name.to_s] + c.to_a.map(&:inspect) + [name.to_s]
+      end
+    end
+
+    widths = printed_columns.map{|col| col.map(&:length).max + 2}
+
+    header + printed_columns.transpose.each_with_index.map do |row, index|
+      row = row.zip(widths).map do |cell, width|
+        cell.rjust(width)
+      end.join('')
+
+      if index == max_section
+        row += "\n" + '-'*widths.reduce(:+)
+      end
+      row
+    end.join("\n")
+  rescue NoMethodError => e
+    raise Exception.new(e)
+  end
+
+  def clone
+    cols = ObjectTable::BasicGrid[columns.map{|k, v| [k, v.clone]}]
+    ObjectTable.new(cols)
+  end
+
+  def _get_sort_index(columns)
+    (0...nrows).zip(columns.map(&:to_a).transpose).sort_by(&:last).map(&:first)
+  end
+
+end

data/lib/object_table/temp_grouped.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+require_relative 'grouped'
+
+class ObjectTable::TempGrouped
+  extend Forwardable
+  def_delegators :make_grouped, :each, :apply
+
+  def initialize(parent, *names, &grouper)
+    @parent = parent
+    @grouper = grouper
+    @names = names
+  end
+
+  def _groups
+    names, keys = _keys()
+    groups = (0...@parent.nrows).zip(keys).group_by{|row, key| key}
+    groups.each do |k, v|
+      groups[k] = NArray.to_na(v.map(&:first))
+    end
+    [names, groups]
+  end
+
+  def _keys
+    if @names.empty?
+      keys = @parent.instance_eval(&@grouper)
+      raise 'Group keys must be hashes' unless keys.is_a?(Hash)
+      keys = ObjectTable::BasicGrid.new.replace keys
+    else
+      keys = ObjectTable::BasicGrid[@names.map{|n| [n, @parent.get_column(n)]}]
+    end
+
+    keys._ensure_uniform_columns!(@parent.nrows)
+    names = keys.keys
+    keys = keys.values.map(&:to_a).transpose
+    [names, keys]
+  end
+
+  def make_grouped
+    names, groups = _groups()
+    ObjectTable::Grouped.new(@parent, names, groups)
+  end
+
+end

data/lib/object_table/temp_view.rb

@@ -0,0 +1,63 @@
+require 'forwardable'
+require_relative 'view_methods'
+require_relative 'masked_column'
+require_relative 'view'
+
+class ObjectTable::TempView
+  include ObjectTable::ViewMethods
+
+  extend Forwardable
+  def_delegators :make_view, :group, :apply
+
+  def initialize(parent, &block)
+    super()
+    @parent = parent
+    @filter = block
+  end
+
+  def_delegators :@parent, :has_column?
+
+  def get_column(name)
+    col = @parent.get_column(name)
+    ObjectTable::MaskedColumn.mask(col, indices) if col
+  end
+  alias_method :[], :get_column
+
+  def make_view
+    ObjectTable::View.new @parent, indices
+  end
+
+  def clone
+    cols = ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, v[indices]]}]
+    ObjectTable.new(cols)
+  end
+
+  def inspect(*args)
+    cache_columns{ super }
+  rescue NoMethodError => e
+    raise Exception.new(e)
+  end
+
+  def indices
+    @indices or NArray.int(@parent.nrows).indgen![@parent.apply &@filter]
+  end
+
+  def cache_indices(&block)
+    @indices = indices
+    value = block.call()
+    @indices = nil
+    value
+  end
+
+  def columns
+    @columns or super
+  end
+
+  def cache_columns(&block)
+    @columns = columns
+    value = block.call()
+    @columns = nil
+    value
+  end
+
+end

data/lib/object_table/version.rb

@@ -0,0 +1,3 @@
+class ObjectTable
+  VERSION = "0.1.0"
+end

data/lib/object_table/view.rb

@@ -0,0 +1,24 @@
+require_relative 'view_methods'
+require_relative 'basic_grid'
+require_relative 'masked_column'
+
+class ObjectTable::View
+  include ObjectTable::ViewMethods
+  attr_reader :indices
+
+  def initialize(parent, indices)
+    super()
+    @parent = parent
+    @indices = indices
+    columns
+  end
+
+  def columns
+    @columns ||= super
+  end
+
+  def add_column(name, *args)
+    @columns[name] = super
+  end
+
+end

data/lib/object_table/view_methods.rb

@@ -0,0 +1,22 @@
+require 'forwardable'
+require_relative 'table_methods'
+
+module ObjectTable::ViewMethods
+  extend Forwardable
+  include ObjectTable::TableMethods
+
+  def columns
+    ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, ObjectTable::MaskedColumn.mask(v, indices)]}]
+  end
+
+  def add_column(name, *args)
+    col = @parent.add_column(name, *args)
+    ObjectTable::MaskedColumn.mask(col, indices)
+  end
+
+  def pop_column(name)
+    @parent.pop_column(name)
+    super if @columns
+  end
+
+end

data/lib/object_table.rb

@@ -0,0 +1,86 @@
+require_relative "object_table/version"
+require_relative "object_table/basic_grid"
+require_relative "object_table/table_methods"
+require_relative "object_table/view"
+require_relative "object_table/temp_view"
+require_relative "object_table/column"
+require_relative "object_table/grouped"
+require_relative "object_table/temp_grouped"
+
+class ObjectTable
+  include TableMethods
+
+  attr_reader :columns
+
+  def initialize(columns = {})
+    super()
+
+    unless columns.is_a? BasicGrid
+      columns = BasicGrid[columns]
+    end
+    columns._ensure_uniform_columns!
+    @columns = columns
+
+    @columns.each do |k, v|
+      @columns[k] = Column.make(v)
+    end
+  end
+
+  def add_column(name, typecode='object', *args)
+    col = ObjectTable::Column.new(typecode, *args, nrows)
+    columns[name] = col
+  end
+
+  def stack!(*others)
+    new_values = Hash.new{ [] }
+
+    others.each do |x|
+      case x
+      when ObjectTable::TableMethods
+        x = x.columns
+      when BasicGrid
+        x._ensure_uniform_columns!
+      end
+
+      raise "Don't know how to append a #{x.class}" unless x.is_a?(BasicGrid)
+      raise 'Mismatch in column names' unless (colnames | x.keys).length == colnames.length
+
+      x.each do |k, v|
+        v = v.to_a if v.is_a? NArray
+        new_values[k] += v
+      end
+    end
+
+    return self if new_values.empty?
+
+    new_values.each do |k, v|
+      @columns[k] = Column.make(@columns[k].to_a + v)
+    end
+    self
+  end
+
+  def self.stack(*values)
+    return self.new if values.empty?
+    base = values.shift
+
+    case base
+    when BasicGrid
+      base = self.new(base.clone)
+    when ObjectTable, ObjectTable::View
+      base = base.clone
+    else
+      raise "Don't know how to join a #{base.class}"
+    end
+    base.stack!(*values)
+  end
+
+  def sort_by!(*keys)
+    sort_index = _get_sort_index(keys)
+
+    columns.each do |k, v|
+      columns[k] = v[sort_index]
+    end
+    self
+  end
+
+end

data/object_table.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'object_table/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "object_table"
+  spec.version       = ObjectTable::VERSION
+  spec.authors       = ["Cheney Lin"]
+  spec.email         = ["lincheney@gmail.com"]
+  spec.summary       = %q{Simple data table table implementation in ruby}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/lincheney/ruby-object-table"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'narray', "~> 0.6"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec', "~> 3.1"
+end
+

data/spec/object_table/basic_grid_spec.rb

@@ -0,0 +1,80 @@
+require 'object_table/basic_grid'
+
+describe ObjectTable::BasicGrid do
+#   describe '.[]' do
+#     subject{ ObjectTable::BasicGrid[] }
+#
+#     it 'should ensure the columns have the same number of rows' do
+#       expect_any_instance_of(ObjectTable::BasicGrid).to receive(:_ensure_uniform_columns!)
+#       subject
+#     end
+#   end
+
+  describe '#_ensure_uniform_columns!' do
+    let(:grid){ ObjectTable::BasicGrid[columns] }
+
+    subject{ grid._ensure_uniform_columns! }
+
+    context 'with rows of the same length' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3]} }
+      it 'should succeed' do
+        subject
+        expect(grid[:col1]).to eql columns[:col1]
+        expect(grid[:col2]).to eql columns[:col2]
+      end
+    end
+
+    context 'with rows of differing length' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3, 4]} }
+      it 'should fail' do
+        expect{subject}.to raise_error
+      end
+    end
+
+    context 'with a mix of scalars and rows' do
+      let(:columns){ {col1: [1, 2, 3], col2: [1, 2, 3], col3: 6} }
+      it 'should recycle the scalar into a full column' do
+        subject
+        expect(grid[:col3]).to eql [6] * 3
+      end
+    end
+
+    context 'with scalars only' do
+      let(:columns){ {col1: 1, col2: 2} }
+      it 'should assume there is one row' do
+        subject
+        expect(grid[:col1]).to eql [columns[:col1]]
+        expect(grid[:col2]).to eql [columns[:col2]]
+      end
+    end
+
+    context 'with ranges' do
+      let(:columns){ {col1: 0...3} }
+      it 'should succeed' do
+        subject
+        expect(grid[:col1]).to eql columns[:col1]
+      end
+    end
+
+    context 'with rank>2 narrays' do
+      context 'with the correct last dimension' do
+        let(:columns) { {col1: NArray[[1, 1], [2, 2], [3, 3]], col2: [1, 2, 3]} }
+
+        it 'should succeed' do
+          subject
+          expect(grid).to eql columns
+        end
+      end
+
+      context 'with an incorrect last dimension' do
+        let(:columns) { {col1: NArray[[1, 2, 3]], col2: [1, 2, 3]} }
+
+        it 'should succeed' do
+          expect{subject}.to raise_error
+        end
+      end
+    end
+
+  end
+
+end

data/spec/object_table/column_spec.rb

@@ -0,0 +1,128 @@
+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
+
+  it "should give the correct result for :#{operator}" do
+    expect(subject.to_a).to eql expected_result.to_a
+  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 '#get_rows' do
+    let(:value)   { NArray.float(50, 50, 50, 50).random! }
+    let(:column)  { ObjectTable::Column.make(value) }
+    let(:index)   { 30 }
+
+    subject{ column.get_rows(index) }
+
+    it 'should retrieve the row from the last dimension' do
+      expect(subject).to eql column[nil, nil, nil, index]
+    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
+
+end