ntable 0.1.0

data/test/tc_slice.rb

@@ -0,0 +1,130 @@
+# -----------------------------------------------------------------------------
+#
+# Table slicing tests
+#
+# -----------------------------------------------------------------------------
+# Copyright 2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'minitest/autorun'
+require 'ntable'
+
+
+module NTable
+  module Tests  # :nodoc:
+
+    class TestSlice < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def setup
+        @labeled_axis_2 = LabeledAxis.new([:one, :two])
+        @labeled_axis_3 = LabeledAxis.new([:red, :white, :blue])
+        @indexed_axis_2 = IndexedAxis.new(2)
+        @indexed_axis_10 = IndexedAxis.new(10,1)
+        @indexed_axis_0 = IndexedAxis.new(0)
+      end
+
+
+      def test_slice_of_no_axes
+        t1_ = Table.new(Structure.new)
+        t2_ = t1_.slice({})
+        assert_equal(t1_, t2_)
+      end
+
+
+      def test_nop_slice_1
+        t1_ = Table.new(Structure.new.add(@labeled_axis_2), :fill => 1)
+        t1s_ = t1_.slice({})
+        assert_equal(t1_, t1s_)
+      end
+
+
+      def test_nop_slice_2
+        t1_ = Table.new(Structure.new.add(@indexed_axis_10, :row).add(@labeled_axis_3, :column), :fill => 1)
+        t1s_ = t1_.slice({})
+        assert_equal(t1_, t1s_)
+      end
+
+
+      def test_slice_1_to_0_indexed
+        t1_ = Table.new(Structure.new.add(@indexed_axis_10, :row), :load => (2..11).to_a)
+        t1s_ = t1_.slice(:row => 3)
+        assert_equal(4, t1s_.get)
+      end
+
+
+      def test_slice_1_to_0_labeled
+        t1_ = Table.new(Structure.new.add(@labeled_axis_3, :col), :load => [2,3,4])
+        t1s_ = t1_.slice(:col => :white)
+        assert_equal(3, t1s_.get)
+      end
+
+
+      def test_slice_2_to_0
+        s1_ = Structure.new.add(@indexed_axis_10, :row).add(@labeled_axis_3, :col)
+        t1_ = Table.new(s1_, :load => (2..31).to_a)
+        t1s_ = t1_.slice(:row => 2, :col => :white)
+        assert_equal(6, t1s_.get)
+      end
+
+
+      def test_slice_2_to_1_major
+        s1_ = Structure.new.add(@indexed_axis_10, :row).add(@labeled_axis_3, :col)
+        t1_ = Table.new(s1_, :load => (2..31).to_a)
+        t1s_ = t1_.slice(:row => 2)
+        t2_ = Table.new(Structure.new.add(@labeled_axis_3, :col), :load => [5,6,7])
+        assert_equal(t2_, t1s_)
+      end
+
+
+      def test_slice_2_to_1_minor
+        s1_ = Structure.new.add(@indexed_axis_10, :row).add(@labeled_axis_3, :col)
+        t1_ = Table.new(s1_, :load => (2..31).to_a)
+        t1s_ = t1_.slice(:col => :white)
+        t2_ = Table.new(Structure.new.add(@indexed_axis_10, :row), :load => [3,6,9,12,15,18,21,24,27,30])
+        assert_equal(t2_, t1s_)
+      end
+
+
+      def test_shared_slice_1_to_0_indexed
+        t1_ = Table.new(Structure.new.add(@indexed_axis_10, :row), :load => (2..11).to_a)
+        t1s_ = t1_.shared_slice(:row => 3)
+        assert_equal(4, t1s_.get)
+        assert_equal(Table.new(Structure.new, :load => [4]), t1s_)
+        t1_.set!(3, :foo)
+        assert_equal(:foo, t1s_.get)
+      end
+
+
+    end
+
+  end
+end

data/test/tc_structure.rb

@@ -0,0 +1,202 @@
+# -----------------------------------------------------------------------------
+#
+# Table structure tests
+#
+# -----------------------------------------------------------------------------
+# Copyright 2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'minitest/autorun'
+require 'ntable'
+
+
+module NTable
+  module Tests  # :nodoc:
+
+    class TestStructure < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def setup
+        @labeled1 = LabeledAxis.new([:one, :two])
+        @labeled2 = LabeledAxis.new([:red, :white, :blue])
+        @indexed1 = IndexedAxis.new(10)
+        @indexed2 = IndexedAxis.new(15, 1)
+        @indexed3 = IndexedAxis.new(0)
+      end
+
+
+      def test_dim_for_various_adds
+        s_ = Structure.new
+        s_.add(@labeled1)
+        assert_equal(1, s_.dim)
+        s_.add(@indexed1)
+        assert_equal(2, s_.dim)
+        s_.add(@indexed1)
+        assert_equal(3, s_.dim)
+      end
+
+
+      def test_add_single_axis
+        s_ = Structure.new
+        s_.add(@labeled1, :first)
+        assert_equal(@labeled1, s_.axis_info(0).axis)
+        assert_equal(@labeled1, s_.axis_info(:first).axis)
+        assert_equal(0, s_.axis_info(:first).index)
+        assert_equal('first', s_.axis_info(0).name)
+      end
+
+
+      def test_add_multi_axis
+        s_ = Structure.new
+        s_.add(@labeled1, :first)
+        s_.add(@indexed1, :second)
+        s_.add(@indexed1)
+        assert_equal(@labeled1, s_.axis_info(0).axis)
+        assert_equal(@labeled1, s_.axis_info(:first).axis)
+        assert_equal(0, s_.axis_info(:first).index)
+        assert_equal('first', s_.axis_info(0).name)
+        assert_equal(@indexed1, s_.axis_info(1).axis)
+        assert_equal(@indexed1, s_.axis_info(:second).axis)
+        assert_equal(1, s_.axis_info(:second).index)
+        assert_equal('second', s_.axis_info(1).name)
+        assert_equal(@indexed1, s_.axis_info(2).axis)
+        assert_nil(s_.axis_info(2).name)
+      end
+
+
+      def test_remove_axis
+        s_ = Structure.new
+        s_.add(@labeled1, :first)
+        s_.add(@indexed1, :second)
+        s_.remove(:first)
+        assert_equal(1, s_.dim)
+        assert_equal(@indexed1, s_.axis_info(0).axis)
+        assert_equal(@indexed1, s_.axis_info(:second).axis)
+        assert_equal(0, s_.axis_info(:second).index)
+        assert_equal('second', s_.axis_info(0).name)
+        assert_nil(s_.axis_info(1))
+        assert_nil(s_.axis_info(:first))
+      end
+
+
+      def test_lock
+        s_ = Structure.new.add(@labeled1)
+        assert_equal(false, s_.locked?)
+        s_.lock!
+        assert_equal(true, s_.locked?)
+      end
+
+
+      def test_size_1
+        s_ = Structure.new.add(@labeled1).lock!
+        assert_equal(2, s_.size)
+      end
+
+
+      def test_size_2
+        s_ = Structure.new.add(@labeled1).add(@indexed1).add(@indexed2).lock!
+        assert_equal(300, s_.size)
+      end
+
+
+      def test_size_no_axes
+        s_ = Structure.new.lock!
+        assert_equal(1, s_.size)
+      end
+
+
+      def test_size_with_empty_axis
+        s_ = Structure.new.add(@labeled1).add(@indexed1).add(@indexed3).lock!
+        assert_equal(0, s_.size)
+      end
+
+
+      def test_offset_labeled1_array
+        s_ = Structure.new.add(@labeled1).lock!
+        assert_equal(0, s_._offset([:one]))
+        assert_equal(1, s_._offset([:two]))
+        assert_nil(s_._offset([:three]))
+      end
+
+
+      def test_offset_labeled1_hash
+        s_ = Structure.new.add(@labeled1, :first_label).lock!
+        assert_equal(0, s_._offset(:first_label => :one))
+        assert_equal(1, s_._offset(:first_label => :two))
+        assert_nil(s_._offset(:first_label => :three))
+        assert_nil(s_._offset(:second_label => :one))
+      end
+
+
+      def test_offset_labeled1_indexed1_array
+        s_ = Structure.new.add(@labeled1).add(@indexed1).lock!
+        assert_equal(2, s_._offset([:one, 2]))
+        assert_equal(13, s_._offset([:two, 3]))
+        assert_equal(10, s_._offset([:two]))
+        assert_nil(s_._offset([:three, 0]))
+      end
+
+
+      def test_offset_labeled1_indexed1_hash
+        s_ = Structure.new.add(@labeled1, :first_axis).add(@indexed1, :second_axis).lock!
+        assert_equal(2, s_._offset(:first_axis => :one, :second_axis => 2))
+        assert_equal(13, s_._offset(:first_axis => :two, :second_axis => 3))
+        assert_equal(5, s_._offset(:second_axis => 5))
+        assert_nil(s_._offset(:first_axis => :three))
+        assert_nil(s_._offset(:third_axis => :three))
+      end
+
+
+      def test_offset_no_axes
+        s_ = Structure.new.lock!
+        assert_equal(0, s_._offset([]))
+        assert_equal(0, s_._offset({}))
+      end
+
+
+      def test_empty_structure_equality
+        assert_equal(Structure.new, Structure.new)
+      end
+
+
+      def test_structure_equality
+        s1_ = Structure.new.add(@labeled1).add(@indexed1)
+        s2_ = Structure.new.add(@labeled1).add(@indexed1)
+        s3_ = Structure.new.add(@indexed1).add(@labeled1)
+        assert_equal(s1_, s2_)
+        refute_equal(s1_, s3_)
+      end
+
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ntable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Azuma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-02 00:00:00.000000000 Z
+dependencies: []
+description: NTable provides a convenient data structure for storing n-dimensional
+  tabular data. It works with zero-dimensional scalar values, arrays, tables, and
+  any arbitrary-dimensional hypertables. Each dimension is described by an axis object.
+  The "rows" in that dimension might be identified by numbers or names. You can perform
+  slice operations across any dimension, as well as reductions and dimensional decomposition.
+  Finally, serialization is provided via a custom JSON schema, as well as a simple
+  "hash of hashes" or "array of arrays" approach.
+email: dazuma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- History.rdoc
+- README.rdoc
+files:
+- lib/ntable/axis.rb
+- lib/ntable/errors.rb
+- lib/ntable/structure.rb
+- lib/ntable/table.rb
+- lib/ntable.rb
+- test/tc_axes.rb
+- test/tc_basic_values.rb
+- test/tc_decompose.rb
+- test/tc_enumeration.rb
+- test/tc_json.rb
+- test/tc_nested_object.rb
+- test/tc_reduce.rb
+- test/tc_slice.rb
+- test/tc_structure.rb
+- History.rdoc
+- README.rdoc
+- Version
+homepage: http://github.com/dazuma/ntable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: virtuoso
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: NTable is an n-dimensional table data structure for Ruby.
+test_files:
+- test/tc_axes.rb
+- test/tc_basic_values.rb
+- test/tc_decompose.rb
+- test/tc_enumeration.rb
+- test/tc_json.rb
+- test/tc_nested_object.rb
+- test/tc_reduce.rb
+- test/tc_slice.rb
+- test/tc_structure.rb