object_table 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b1327f62f465f8305a265b6a7f865c5ca43a66b
-  data.tar.gz: 8dc9d380fecb0ac14556f3cbe38acae87ec943b3
+  metadata.gz: 47a4b77bf7199464216dd309096200c6870cdda1
+  data.tar.gz: d34284715a8a0340f48e19bfb522c22bd570e5da
 SHA512:
-  metadata.gz: 666c0551cef6acff77df23fee41986c49b05e2959bb770d0c1ed06cee357774c9e57a31f359eb50603be8d9f87e03b216eec4272a1cb6e2b8ab420a934513c40
-  data.tar.gz: 18841d8933d04755b955fd6882fb7d8480d199d442306c0a02d44b041984f7f131f0f81d7bd4e5c4da277b4fca91847bae7d35e2a8fc63771119f8a14989e222
+  metadata.gz: cdb8e5894a5880b36635847962d9fabfb6e998be2f46d633c9d4e0c9519f678b20e9c61906a15cc6ee15b6bf8a1ec896d26c0c6e9a970abe07412b16ea8b48db
+  data.tar.gz: a42440c3488fecaf1e68b0d5ff2f5d0b49ec98a7f899758f13b1bddf9040c4920574a37814219ad312c875c9c0fb646fa375ff9c2ff0bef28830768e8d4d3554

data/README.md

@@ -464,6 +464,7 @@ The act of subclassing itself is easy, but any methods you add won't be availabl
         a + b
       end
     end
+...
 
 >>> data = BrokenTable.new(a: 1..3, b: 4..6)
 >>> data.a_plus_b
@@ -475,14 +476,12 @@ The act of subclassing itself is easy, but any methods you add won't be availabl
 NoMethodError: undefined method `a_plus_b' for #<ObjectTable::View:0x000000011d4dd0>
 ```
 
-To make it work, you'll need to subclass `View`, `StaticView` and `Group` too. Then set the `Table` constant on each. The easiest way is just to include a module.
+To make it work, you'll need to subclass `View`, `StaticView` and `Group` too and assign those subclasses under your ObjectTable subclass.
+The easiest way is just to include a module with your common methods.
 
 ```ruby
 >>> class WorkingTable < ObjectTable
       module Mixin
-        # this mixin will set the Table constant on each of the subclasses
-        Table = WorkingTable
-
         def a_plus_b
           a + b
         end
@@ -495,6 +494,7 @@ To make it work, you'll need to subclass `View`, `StaticView` and `Group` too. T
       class View < View; include Mixin; end
       class Group < Group; include Mixin; end
     end
+...
 
 >>> data = WorkingTable.new(a: 1..3, b: 4..6)
 >>> data.a_plus_b
@@ -510,6 +510,8 @@ To make it work, you'll need to subclass `View`, `StaticView` and `Group` too. T
 >>> data.group_by{{odd: a % 2}}.each do
       p "when a % 2 == #{@K[:odd]}, a + b == #{a_plus_b.to_a}"
     end
+...
+
 "when a % 2 == 1, a + b == [5, 9]"
 "when a % 2 == 0, a + b == [7]"
 ```

data/lib/object_table/column.rb

@@ -1,6 +1,12 @@
 require 'narray'
 
 class ObjectTable::Column < NArray
+  NARRAY_ENUMERATORS = [:to_a, :collect, :map, :sort, :all?, :any?, :max, :min, :none?]
+
+  NARRAY_ENUMERATORS.each{|method| alias_method "narray_#{method}", method}
+  include Enumerable
+  NARRAY_ENUMERATORS.each{|method| alias_method method, "narray_#{method}"}
+
   def self.make(value)
     value = case value
     when self
@@ -25,17 +31,25 @@ class ObjectTable::Column < NArray
     self.class.make super
   end
 
-  def [](*)
+  def [](*a)
     result = super
     result.is_a?(NArray) ? self.class.make(result) : result
   end
 
-  def get_rows(rows, slice=false)
-    if slice
-      slice(*([nil] * (rank - 1)), rows)
-    else
-      self[*([nil] * (rank - 1)), rows]
+  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
@@ -77,4 +91,20 @@ class ObjectTable::Column < NArray
 # #     end
 #   end
 
+  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)
+
+    padding = [nil] * (rank - 1)
+
+    row = 0
+    columns.each do |col|
+      new_col[*padding, row ... (row + col.shape[-1])] = col
+      row += col.shape[-1]
+    end
+
+    new_col
+  end
+
 end

data/lib/object_table/grouped.rb

@@ -1,32 +1,67 @@
 require_relative 'group'
+require_relative 'table_child'
 
 class ObjectTable::Grouped
   DEFAULT_VALUE_PREFIX = 'v_'
+  include ObjectTable::TableChild
 
-  def initialize(parent, names, groups)
+  def initialize(parent, *names, &grouper)
     @parent = parent
+    @grouper = grouper
     @names = names
-    @groups = groups
   end
 
-  def each(&block)
-    group_cls = @parent.class::Table::Group
 
-    @groups.each do |k, v|
-      names = @names.zip(k)
-      group_cls.new(@parent, Hash[names], v).apply &block
+  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.apply(&@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
+
+  %w{ all? any? collect collect_concat count flat_map map none? one? }.each do |method|
+    define_method(method) do |*args, &block|
+      names, groups = _groups()
+      groups.send(method, *args) do |k, v|
+        keys = names.zip(k)
+        __group_cls__.new(@parent, Hash[keys], v).apply &block
+      end
+    end
+  end
+
+  def each(&block)
+    names, groups = _groups()
+    groups.each do |k, v|
+      keys = names.zip(k)
+      __group_cls__.new(@parent, Hash[keys], v).apply &block
     end
     @parent
   end
 
   def apply(&block)
-    table_cls = @parent.class::Table
-    group_cls = table_cls::Group
-    value_key = self.class._generate_name(DEFAULT_VALUE_PREFIX, @names).to_sym
+    names, groups = _groups()
+    value_key = self.class._generate_name(DEFAULT_VALUE_PREFIX, names).to_sym
 
-    data = @groups.map do |k, v|
-      names = @names.zip(k)
-      value = group_cls.new(@parent, Hash[names], v).apply &block
+    data = groups.map do |k, v|
+      keys = names.zip(k)
+      value = __group_cls__.new(@parent, Hash[keys], v).apply &block
 
       if value.is_a?(ObjectTable::TableMethods)
         value = value.columns
@@ -34,14 +69,14 @@ class ObjectTable::Grouped
 
       grid = case value
       when ObjectTable::BasicGrid
-        ObjectTable::BasicGrid[names].merge!(value)
+        ObjectTable::BasicGrid[keys].merge!(value)
       else
-        ObjectTable::BasicGrid[names + [[value_key, value]]]
+        ObjectTable::BasicGrid[keys + [[value_key, value]]]
       end
       grid._ensure_uniform_columns!
     end
 
-    table_cls.stack(*data)
+    __table_cls__.stack(*data)
   end
 
   def self._generate_name(prefix, existing_names)

data/lib/object_table/masked_column.rb

@@ -4,7 +4,11 @@ class ObjectTable::MaskedColumn < ObjectTable::Column
   attr_accessor :indices, :parent, :padded_dims
 
   def self.mask(parent, indices)
-    padded_dims = [nil] * (parent.rank - 1)
+    if parent.rank > 1
+      padded_dims = [nil] * (parent.rank - 1)
+    else
+      padded_dims = []
+    end
     masked = parent.slice(*padded_dims, indices)
 
     if masked.rank <= 0
@@ -28,27 +32,21 @@ class ObjectTable::MaskedColumn < ObjectTable::Column
   alias_method :super_slice_assign, :[]=
 
   def []=(*keys, value)
-    unless (value.is_a?(Array) or value.is_a?(NArray)) and value.empty?
+    unless parent.nil? or ((value.is_a?(Array) or value.is_a?(NArray)) and value.empty?)
       parent[*padded_dims, indices[*keys]] = value
-      super
     end
+    super
   end
 
 #   make destructive methods affect parent
   %w{ fill! indgen! indgen random! map! collect! conj! imag= mod! add! div! sbt! mul! }.each do |op|
     define_method(op) do |*args, &block|
       result = super(*args, &block)
-      parent[*padded_dims, indices] = result
+      parent[*padded_dims, indices] = result if parent
       result
     end
   end
 
-  %w{ + - / * % ** to_type not abs -@ ~ }.each do |op|
-    define_method(op) do |*args|
-      ObjectTable::Column.cast super(*args)
-    end
-  end
-
   def clone
     ObjectTable::Column.cast(self).clone
   end

data/lib/object_table/printable.rb

@@ -0,0 +1,72 @@
+module ObjectTable::Printable
+
+  def self.get_printable_column(name, column)
+    padding = [nil] * (column.rank - 1)
+    rows = column.shape[-1].times.map do |i|
+      row = column[*padding, i]
+      str = row.is_a?(NArray) ? row.inspect.partition("\n")[-1].strip : row.inspect
+      str.split("\n")
+    end
+
+    name = name.to_s
+    [[name]] + rows + [[name]]
+  end
+
+  def self.get_printable_line_numbers(numbers)
+    rows = numbers.map do |i|
+      ["#{i}: "]
+    end
+
+    [['']] + rows + [['']]
+  end
+
+  def inspect(max_section = 5, col_padding = 2)
+    header = "#{self.class}(#{nrows}, #{ncols})\n"
+
+    return (header + "(empty table)") if ncols == 0
+    return (header + "(empty table with columns: #{colnames.join(", ")})") if nrows == 0
+
+    printed_columns = []
+
+    if nrows > max_section * 2
+      head = (0...max_section)
+      tail = ((nrows - max_section)...nrows)
+
+      printed_columns.push ObjectTable::Printable.get_printable_line_numbers(head.to_a + tail.to_a)
+
+      printed_columns += columns.map do |name, c|
+        padding = [nil] * (c.rank - 1)
+        c = c.slice(*padding, [head, tail])
+        ObjectTable::Printable.get_printable_column(name, c)
+      end
+    else
+      max_section = -1
+      printed_columns.push ObjectTable::Printable.get_printable_line_numbers(0...nrows)
+      printed_columns += columns.map do |name, c|
+        ObjectTable::Printable.get_printable_column(name, c)
+      end
+    end
+
+    widths = printed_columns.map{|row| row.flat_map{|c| c.map(&:length)}.max + col_padding}
+
+    header + printed_columns.transpose.each_with_index.map do |row, index|
+      height = row.map(&:length).max
+
+      row = row.zip(widths).map do |cell, width|
+        cell += [" "] * (height - cell.length)
+        cell.map{|i| i.rjust(width)}
+      end
+
+      row = row.transpose.map{|i| i.join('')}.join("\n")
+
+      if index == max_section
+        row += "\n" + '-'*widths.reduce(:+)
+      end
+      row
+    end.join("\n")
+
+  rescue NoMethodError => e
+    raise Exception.new(e)
+  end
+
+end

data/lib/object_table/table_child.rb

@@ -0,0 +1,19 @@
+module ObjectTable::TableChild
+
+  def __static_view_cls__
+    @__static_view_cls__ ||= @parent.__static_view_cls__
+  end
+
+  def __view_cls__
+    @__view_cls__ ||= @parent.__view_cls__
+  end
+
+  def __group_cls__
+    @__group_cls__ ||= @parent.__group_cls__
+  end
+
+  def __table_cls__
+    @__table_cls__ ||= @parent.__table_cls__
+  end
+
+end

data/lib/object_table/table_methods.rb

@@ -1,11 +1,8 @@
 require 'forwardable'
+require_relative 'printable'
 
 module ObjectTable::TableMethods
-  # this line is important!! which classes to use to make Views/StaticViews/Groups
-  # are taken from this constant, e.g. Table::View
-  Table = ObjectTable
-
-
+  include ObjectTable::Printable
   extend Forwardable
 
   attr_reader :R
@@ -77,23 +74,23 @@ module ObjectTable::TableMethods
     end
 
     if result.is_a? ObjectTable::BasicGrid
-      result = self.class::Table.new(result)
+      result = __table_cls__.new(result)
     end
     result
   end
 
   def where(&block)
-    self.class::Table::View.new(self, &block)
+    __view_cls__.new(self, &block)
   end
 
   def group_by(*args, &block)
-    ObjectTable::TempGrouped.new(self, *args, &block)
+    ObjectTable::Grouped.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]]}]
-    self.class::Table.new(cols)
+    __table_cls__.new(cols)
   end
 
   def method_missing(meth, *args, &block)
@@ -104,51 +101,9 @@ module ObjectTable::TableMethods
     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]}]
-    self.class::Table.new(cols)
+    __table_cls__.new(cols)
   end
 
   def _get_sort_index(columns)

data/lib/object_table/version.rb

@@ -1,3 +1,3 @@
 class ObjectTable
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/object_table/view.rb

@@ -3,7 +3,6 @@ require_relative 'view_methods'
 require_relative 'masked_column'
 
 class ObjectTable::View
-  Table = ObjectTable
   include ObjectTable::ViewMethods
 
   extend Forwardable
@@ -24,12 +23,12 @@ class ObjectTable::View
   alias_method :[], :get_column
 
   def make_view
-    self.class::Table::StaticView.new @parent, indices
+    __static_view_cls__.new @parent, indices
   end
 
   def clone
     cols = ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, v[indices]]}]
-    self.class::Table.new(cols)
+    __table_cls__.new(cols)
   end
 
   def inspect(*args)

data/lib/object_table/view_methods.rb

@@ -1,9 +1,11 @@
 require 'forwardable'
 require_relative 'table_methods'
+require_relative 'table_child'
 
 module ObjectTable::ViewMethods
   extend Forwardable
   include ObjectTable::TableMethods
+  include ObjectTable::TableChild
 
   def columns
     ObjectTable::BasicGrid[@parent.columns.map{|k, v| [k, ObjectTable::MaskedColumn.mask(v, indices)]}]

data/lib/object_table.rb

@@ -5,7 +5,6 @@ require_relative "object_table/view"
 require_relative "object_table/static_view"
 require_relative "object_table/column"
 require_relative "object_table/grouped"
-require_relative "object_table/temp_grouped"
 
 class ObjectTable
   include TableMethods
@@ -32,7 +31,7 @@ class ObjectTable
   end
 
   def stack!(*others)
-    new_values = Hash.new{ [] }
+    new_values = Hash[colnames.zip(ncols.times.map{[]})]
 
     others.each do |x|
       case x
@@ -47,15 +46,17 @@ class ObjectTable
       raise 'Mismatch in column names' unless (colnames | x.keys) == (colnames & x.keys)
 
       x.each do |k, v|
-        v = v.to_a if v.is_a? NArray
-        new_values[k] += v
+        new_values[k].push NArray.to_na(v)
       end
     end
 
     return self if new_values.empty?
+    new_rows = new_values.values.first.map{|x| x.shape[-1]}.reduce(:+)
+    return self unless (new_rows and new_rows != 0)
+    new_rows += nrows
 
     new_values.each do |k, v|
-      @columns[k] = ObjectTable::Column.make(@columns[k].to_a + v)
+      @columns[k] = @columns[k].stack(*v)
     end
     self
   end
@@ -84,4 +85,89 @@ class ObjectTable
     self
   end
 
+  def join(other, key, options={})
+    type = (options[:type] || 'inner')
+    key = [key] unless key.is_a?(Array)
+
+    lkeys = key.map{|k| get_column(k).to_a}.transpose
+    rkeys = key.map{|k| other[k].to_a}.transpose
+
+    rgroups = rkeys.each_with_index.group_by(&:first)
+    rgroups.each{|k, v| rgroups[k] = v.transpose[-1]}
+
+    rindex = rgroups.values_at(*lkeys)
+    lindex = lkeys.each_with_index.zip(rindex).flat_map{|(k, i), r| [i] * r.length if r}
+    lindex.compact!
+
+    right_cols = other.colnames - key
+    left_cols = colnames
+
+    if type == 'left' or type == 'outer'
+      lmissing = NArray.to_na(rindex.map{|x| x ? 0 : 1}).where.to_a
+      lindex += lmissing
+      rindex += [-1] * lmissing.length
+    end
+
+    if type == 'right' or type == 'outer'
+      left_cols -= key
+      rmissing = rgroups.values - rindex
+      rmissing.flatten!
+      lindex += [-1] * rmissing.length
+      rindex += rmissing
+    end
+
+    rindex.flatten!.compact!
+
+    lindex = NArray.to_na(lindex)
+    rindex = NArray.to_na(rindex)
+    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]
+    end
+
+    keys = []
+    if type == 'right' or type == 'outer'
+      keys = key.map do |k|
+        col = get_column(k)
+        padding = [nil] * (col.rank - 1)
+        col = col[*padding, lindex]
+        col[*padding, lblank] = other[k][*padding, rmissing]
+        [k, col]
+      end
+    end
+
+    self.class.new(keys + left + right)
+  end
+
+
+  def __static_view_cls__
+    self.class::StaticView
+  end
+
+  def __view_cls__
+    self.class::View
+  end
+
+  def __group_cls__
+    self.class::Group
+  end
+
+  def __table_cls__
+    self.class
+  end
+
 end