object_table 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14a01cfa80b77105e5a243dbaacc894fec8fa9ad
+  data.tar.gz: 6bf1d3259550812b745eee202f0937bf7c278732
+SHA512:
+  metadata.gz: 1106df0b67029df89d4e8f52e171946f38f4a19c6c16fc0c316823731c8d073fa565b35ce141c2dc399c8d2f2d9002ab11e25178b38cb686db656fc5e4e5fb09
+  data.tar.gz: 8a6423b764125e33c092c7d80dbc5fab723995f82873528f8d72e441d54bbe2340b2f9a2022e521fe2d762db0dcbe0fbe90cdfce78643e3479932bb46ad242fe

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in object_table.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 lincheney
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,322 @@
+ruby-object-table
+=================
+
+Simple data table/frame implementation in ruby
+Probably slow and extremely inefficient, but it works and that's all that matters.
+Uses NArrays (https://github.com/masa16/narray) for storing data.
+
+## Creating a table
+
+Just pass a hash of columns into the constructor.
+You can use vectors types (Array, NArray, Range) or scalars (basically anything else).
+
+### Initialising with vector types
+
+```ruby
+>>> ObjectTable.new(array: [1, 2, 3], narray: NArray[4, 5, 6], range: 7..9)
+ => ObjectTable(3, 3)
+       array  narray  range
+  0:       1       4      7
+  1:       2       5      8
+  2:       3       6      9
+       array  narray  range 
+
+# columns with uneven lengths gives an error
+>>> ObjectTable.new(a: [1, 2, 3], b: [4, 5, 6, 7])
+RuntimeError: Differing number of rows: [3, 4]
+```
+
+### With scalar types
+
+With all scalar columns, a one-row table is assumed
+```ruby
+>>> ObjectTable.new(a: 1, b: 2)
+ => ObjectTable(1, 2)
+       a  b
+  0:   1  2
+       a  b 
+```
+
+Otherwise the scalars are extended to match the length of the vector columns
+```ruby
+>>> ObjectTable.new(a: [1, 2, 3], b: 100)
+ => ObjectTable(3, 2)
+       a    b
+  0:   1  100
+  1:   2  100
+  2:   3  100
+       a    b 
+```
+
+## Methods
+
+- `#ncols` returns the number of columns
+- `#nrows` returns the number of rows
+- `#colnames` returns an array of the column names
+- `#clone` make a copy of the table
+- `#stack(table1, table2, ...)` appends then supplied tables
+- `#apply(&block)` evaluates `block` in the context of the table
+- `#where(&block)` filters the table
+- `#group(&block)` splits the table into groups
+
+### Getting columns
+
+You can get a column by using `#[]` or using the column name as a method.
+
+```ruby
+>>> data = ObjectTable.new(a: [1, 2, 3], b: 100, c: ['a', 'b', 'c'])
+
+# using a method
+>>> data.a
+ => ObjectTable::Column.int(3): 
+[ 1, 2, 3 ] 
+
+# ... or using []
+>>> data[:a]
+ => ObjectTable::Column.int(3): 
+[ 1, 2, 3 ] 
+```
+
+### Setting columns
+
+You can set/add columns by using `#[]=`.
+
+```ruby
+>>> data = ObjectTable.new(a: [1, 2, 3], b: 100, c: ['a', 'b', 'c'])
+
+# replace an old column with a vector
+>>> data[:a] = [4, 5, 6]
+>>> data
+ => ObjectTable(3, 3)
+       a    b    c
+  0:   4  100  "a"
+  1:   5  100  "b"
+  2:   6  100  "c"
+       a    b    c 
+
+# ... or with a scalar
+>>> data[:c] = "scalar string"
+>>> data
+ => ObjectTable(3, 3)
+       a    b                c
+  0:   4  100  "scalar string"
+  1:   5  100  "scalar string"
+  2:   6  100  "scalar string"
+       a    b                c 
+
+# ... and do the same for a new column
+>>> data[:new_column] = 10...13
+>>> data
+ => ObjectTable(3, 4)
+       a    b                c  new_column
+  0:   4  100  "scalar string"          10
+  1:   5  100  "scalar string"          11
+  2:   6  100  "scalar string"          12
+       a    b                c  new_column 
+
+# ... but make sure they have the right length
+>>> data[:a] = [1, 2, 3, 4]
+IndexError: dst.shape[0]=3 != src.shape[0]=4
+>>> data[:another_column] = [1, 2, 3, 4]
+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
+
+```ruby
+>>> data = ObjectTable.new(column: ['abc', 'bcd', 'cde'])
+>>> data.column.match(/bc/)
+ => ObjectTable::Column.object(3): 
+[ #<MatchData "bc">, #<MatchData "bc">, nil ] 
+```
+
+### `#apply`
+
+This is just a convenience method.
+It basically `#instance_eval`s the block passed to it.
+
+```ruby
+>>> data = ObjectTable.new(a: [1, 2, 3], b: [4, 5, 6])
+
+# this is exactly the same as (data.a + data.b)
+>>> data.apply{ a + b }
+ => ObjectTable::Column.int(3): 
+[ 5, 7, 9 ] 
+
+# you can use self to set/add columns
+>>> data.apply{ self[:c] = a * b }
+>>> data
+ => ObjectTable(3, 3)
+       a  b   c
+  0:   1  4   4
+  1:   2  5  10
+  2:   3  6  18
+       a  b   c 
+```
+
+## Filtering
+
+Use the `#where` method and pass a filtering block.
+The block is evaluated in the context of the table (like for `#apply`).
+This creates a `TempView` which syncs with the parent table.
+This means any changes made to the parent also affect the view.
+
+```ruby
+>>> data = ObjectTable.new(a: 0...5, b: 5...10)
+>>> a_lt_3 = data.where{ a < 3 }
+ => ObjectTable::TempView(3, 2)
+       a  b
+  0:   0  5
+  1:   1  6
+  2:   2  7
+       a  b 
+
+# update the parent table
+>>> data[:b] = data.b.reverse
+# and the view gets updated too
+>>> a_lt_3
+ => ObjectTable::TempView(3, 2)
+       a  b
+  0:   0  9
+  1:   1  8
+  2:   2  7
+       a  b 
+
+# you can also chain #where calls
+>>> data.where{ a < 3 }.where{ b > 7 }
+ => ObjectTable::TempView(3, 2)
+       a  b
+  0:   0  9
+  1:   1  8
+       a  b 
+# which is the same as
+>>> data.where{ a < 3 && b > 7 }
+```
+
+Changes are propagated to the parent.
+This means any changes made to the view also affect the parent.
+
+```ruby
+>>> data.where{ a < 3 }[:b] = 100
+>>> data
+ => ObjectTable(5, 2)
+       a    b
+  0:   4    5
+  1:   3    6
+  2:   2  100
+  3:   1  100
+  4:   0  100
+       a    b 
+
+# changes made to chained filters are propagated too
+>>> data.where{ a > 3 }.where{ b < 100 }[:b] = -100
+>>> data
+ => ObjectTable(5, 2)
+       a     b
+  0:   4  -100
+  1:   3     6
+  2:   2   100
+  3:   1   100
+  4:   0   100
+       a     b 
+```
+
+### Adding new columns
+
+Added columns have a default value of `nil` outside the view.
+
+```ruby
+>>> data = ObjectTable.new(a: 0...5, b: 5...10)
+# where a < 3, c will be 5, elsewhere it will be nil
+>>> data.where{ a < 3 }[:c] = 5
+>>> data
+ => ObjectTable(5, 3)
+       a  b    c
+  0:   0  5    5
+  1:   1  6    5
+  2:   2  7    5
+  3:   3  8  nil
+  4:   4  9  nil
+       a  b    c 
+```
+
+### Other notes
+
+You can also use `#apply` on a view (as for a table).
+
+If you want to filter a table and keep that data (i.e. without it syncing with the parent, propagating changes etc.) just `#clone` it.
+
+## Grouping (and aggregating)
+
+Use the `#group` method and pass a block that returns grouping keys.
+Then call `#each` to iterate through the groups or `#apply` to aggregate the results.
+The blocks are evaluated in the context of the table (in the case of `#apply`, the context of the group).
+
+The argument to `#group` should be a hash mapping key name => key. See the below example.
+
+```ruby
+>>> data = ObjectTable.new(name: ['John', 'Tom', 'Jim', 'Tim', 'Jack'], value: 1..5)
+         name  value
+  0:   "John"      1
+  1:    "Tom"      2
+  2:    "Jim"      3
+  3:    "Tim"      4
+  4:   "Jack"      5
+         name  value 
+
+# group by the first letter of the name and print out each group
+>>> data.group{ {initial: name.map{|n| n[0]}} }.each{ p self; puts }
+ObjectTable::View(3, 2)
+         name  value
+  0:   "John"      1
+  1:    "Jim"      3
+  2:   "John"      5
+         name  value
+
+ObjectTable::View(2, 2)
+        name  value
+  0:   "Tom"      2
+  1:   "Tim"      4
+        name  value
+
+# calculate the average 'value' for each group and get the result in a table
+>>> data.group{ {initial: name.map{|n| n[0]}} }.apply{ value.mean }
+ => ObjectTable(2, 2)
+       initial  v_0                                        
+  0:       "J"  3.0                                        
+  1:       "T"  3.0                                        
+       initial  v_0
+```
+
+### Aggregation
+
+Normally you can only have one aggregated column with a default name of v_0.
+You can have more columns and set column names by making a `ObjectTable` or using the @R shortcut.
+
+```ruby
+>>> data.group{ {initial: name.map{|n| n[0]}} }.apply{ @R[ mean: value.mean, sum: value.sum ] }
+ => ObjectTable(2, 4)
+       initial  mean  sum                 std
+  0:       "J"   3.0    9                 2.0
+  1:       "T"   3.0    6  1.4142135623730951
+       initial  mean  sum                 std 
+```
+
+### Assigning to columns
+
+Assigning to columns will assign by group.
+
+```ruby
+>>> data.group{ {initial: name.map{|n| n[0]}} }.each{ self[:num_same_initial] = nrows }
+ => ObjectTable(5, 3)
+         name  value  num_same_initial
+  0:   "John"      1                 3
+  1:    "Tom"      2                 2
+  2:    "Jim"      3                 3
+  3:    "Tim"      4                 2
+  4:   "John"      5                 3
+         name  value  num_same_initial 
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+

data/lib/object_table/basic_grid.rb

@@ -0,0 +1,33 @@
+require 'narray'
+
+class ObjectTable::BasicGrid < Hash
+  ARRAY_LIKE = [Array, Range]
+
+#   def self.[](*args)
+#     grid = super
+#     grid._ensure_uniform_columns!
+#   end
+
+  def _ensure_uniform_columns!(rows = nil)
+    arrays, scalars = partition{|k, v| ARRAY_LIKE.any?{|cls| v.is_a?(cls)} }
+    narrays, scalars = scalars.partition{|k, v| v.is_a?(NArray) }
+
+    unique_rows = arrays.map{|k, v| v.count}
+    unique_rows += narrays.map{|k, v| v.shape.last}
+    unique_rows = unique_rows.uniq
+
+    if rows
+      raise "Differing number of rows: #{unique_rows}" unless unique_rows.empty? or unique_rows == [rows]
+    else
+      raise "Differing number of rows: #{unique_rows}" if unique_rows.length > 1
+      rows = (unique_rows[0] or 1)
+    end
+
+    scalars.each do |k, v|
+      self[k] = [v] * rows
+    end
+
+    self
+  end
+
+end

data/lib/object_table/column.rb

@@ -0,0 +1,80 @@
+require 'narray'
+
+class ObjectTable::Column < NArray
+  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 [](*)
+    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]
+    end
+  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
+
+end

data/lib/object_table/grouped.rb

@@ -0,0 +1,58 @@
+require_relative 'view'
+
+class ObjectTable::Grouped
+  DEFAULT_VALUE_PREFIX = 'v_'
+
+  class Group < ObjectTable::View
+    attr_reader :K
+
+    def initialize(parent, keys, value)
+      super(parent, value)
+      @K = keys
+    end
+  end
+
+  def initialize(parent, names, groups)
+    @parent = parent
+    @names = names
+    @groups = groups
+  end
+
+  def each(&block)
+    @groups.each do |k, v|
+      names = @names.zip(k)
+      Group.new(@parent, Hash[names], v).apply &block
+    end
+    @parent
+  end
+
+  def apply(&block)
+    value_key = self.class._generate_name(DEFAULT_VALUE_PREFIX, @names).to_sym
+
+    data = @groups.map do |k, v|
+      names = @names.zip(k)
+      value = Group.new(@parent, Hash[names], v).apply &block
+
+      if value.is_a?(ObjectTable::TableMethods)
+        value = value.columns
+      end
+
+      grid = case value
+      when ObjectTable::BasicGrid
+        ObjectTable::BasicGrid[names].merge!(value)
+      else
+        ObjectTable::BasicGrid[names + [[value_key, value]]]
+      end
+      grid._ensure_uniform_columns!
+    end
+
+    ObjectTable.stack(*data)
+  end
+
+  def self._generate_name(prefix, existing_names)
+    regex = Regexp.new(Regexp.quote(prefix) + '(\d+)')
+    i = existing_names.map(&regex.method(:match)).compact.map{|match| match[-1].to_i}.max || -1
+    "#{prefix}#{i + 1}"
+  end
+
+end

data/lib/object_table/masked_column.rb

@@ -0,0 +1,54 @@
+require_relative 'column'
+
+class ObjectTable::MaskedColumn < ObjectTable::Column
+  attr_accessor :indices, :parent, :padded_dims
+
+  def self.mask(parent, indices)
+    padded_dims = [nil] * (parent.rank - 1)
+    masked = parent.slice(*padded_dims, indices)
+
+    if masked.rank <= 0
+      column = self.new(masked.typecode, 0)
+    else
+      column = self.new(masked.typecode, *masked.shape)
+      column.super_slice_assign(masked)
+    end
+
+    column.parent = parent
+    column.indices = indices
+    column.padded_dims = padded_dims
+    column
+  end
+
+# let ObjectTable::Column do this, since we've overriden []=
+  def self.make(*args)
+    ObjectTable::Column.make(*args)
+  end
+
+  alias_method :super_slice_assign, :[]=
+
+  def []=(*keys, value)
+    parent[*padded_dims, indices[*keys]] = value
+    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
+      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
+
+end