ntable 0.1.0

data/test/tc_json.rb

@@ -0,0 +1,137 @@
+# -----------------------------------------------------------------------------
+#
+# Test serialization as JSON
+#
+# -----------------------------------------------------------------------------
+# 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 TestJSON < ::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)
+      end
+
+
+      def test_labeled_axis_2
+        json_ = {}
+        @labeled_axis_2.to_json_object(json_)
+        assert_equal({'labels' => ['one', 'two']}, json_)
+        naxis_ = LabeledAxis.allocate
+        naxis_.from_json_object(json_)
+        assert_equal(@labeled_axis_2, naxis_)
+      end
+
+
+      def test_labeled_axis_3
+        json_ = {}
+        @labeled_axis_3.to_json_object(json_)
+        assert_equal({'labels' => ['red', 'white', 'blue']}, json_)
+        naxis_ = LabeledAxis.allocate
+        naxis_.from_json_object(json_)
+        assert_equal(@labeled_axis_3, naxis_)
+      end
+
+
+      def test_indexed_axis_2
+        json_ = {}
+        @indexed_axis_2.to_json_object(json_)
+        assert_equal({'size' => 2}, json_)
+        naxis_ = IndexedAxis.allocate
+        naxis_.from_json_object(json_)
+        assert_equal(@indexed_axis_2, naxis_)
+      end
+
+
+      def test_indexed_axis_10
+        json_ = {}
+        @indexed_axis_10.to_json_object(json_)
+        assert_equal({'size' => 10, 'start' => 1}, json_)
+        naxis_ = IndexedAxis.allocate
+        naxis_.from_json_object(json_)
+        assert_equal(@indexed_axis_10, naxis_)
+      end
+
+
+      def test_structure
+        structure_ = Structure.add(@indexed_axis_10, 'row').add(@indexed_axis_2).add(@labeled_axis_3, 'col')
+        json_ = structure_.to_json_array
+        expected_json_ = [
+          {'type' => 'indexed', 'name' => 'row', 'size' => 10, 'start' => 1},
+          {'type' => 'indexed', 'size' => 2},
+          {'type' => 'labeled', 'name' => 'col', 'labels' => ['red', 'white', 'blue']}
+        ]
+        assert_equal(expected_json_, json_)
+        nstructure_ = Structure.from_json_array(json_)
+        assert_equal(structure_, nstructure_)
+      end
+
+
+      def test_empty_structure
+        structure_ = Structure.new
+        json_ = structure_.to_json_array
+        assert_equal([], json_)
+        nstructure_ = Structure.from_json_array(json_)
+        assert_equal(structure_, nstructure_)
+      end
+
+
+      def test_table_2d_json_object
+        table_ = Table.new(Structure.add(@indexed_axis_10, 'row').add(@labeled_axis_3, 'col'),
+          :load => (0..29).to_a)
+        json_ = table_.to_json_object
+        expected_json_ = {
+          'type' => 'ntable',
+          'axes' => [{'type' => 'indexed', 'name' => 'row', 'size' => 10, 'start' => 1},
+            {'type' => 'labeled', 'name' => 'col', 'labels' => ['red', 'white', 'blue']}],
+          'values' => (0..29).to_a
+        }
+        assert_equal(expected_json_, json_)
+        ntable_ = Table.from_json_object(json_)
+        assert_equal(table_, ntable_)
+      end
+
+
+    end
+
+  end
+end

data/test/tc_nested_object.rb

@@ -0,0 +1,191 @@
+# -----------------------------------------------------------------------------
+#
+# Test serialization as nested objects
+#
+# -----------------------------------------------------------------------------
+# 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 TestNestedObject < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def setup
+        @labeled_axis_2 = LabeledAxis.new([:one, :two])
+        @labeled_axis_3 = LabeledAxis.new([:blue, :red, :white])
+        @indexed_axis_2 = IndexedAxis.new(2)
+        @indexed_axis_10 = IndexedAxis.new(10, 1)
+        @labeled_axis_0 = LabeledAxis.new([])
+        @indexed_axis_0 = IndexedAxis.new(0)
+      end
+
+
+      def test_from_empty_labeled
+        t1_ = Table.from_nested_object({})
+        assert_equal(Table.new(Structure.add(@labeled_axis_0)), t1_)
+      end
+
+
+      def test_to_empty_labeled
+        t1_ = Table.new(Structure.add(@labeled_axis_0))
+        assert_equal({}, t1_.to_nested_object)
+      end
+
+
+      def test_from_level_1_labeled
+        obj_ = {:one => 1, :two => 2}
+        t1_ = Table.from_nested_object(obj_, [{:sort => true}])
+        assert_equal(Table.new(Structure.add(@labeled_axis_2), :load => [1,2]), t1_)
+      end
+
+
+      def test_to_level_1_labeled
+        t1_ = Table.new(Structure.add(@labeled_axis_2), :load => [1,2])
+        assert_equal({'one' => 1, 'two' => 2}, t1_.to_nested_object)
+      end
+
+
+      def test_from_level_2_labeled
+        obj_ = {:one => {:red => 1, :white => 2}, :two => {:white => 3, :blue => 4}}
+        t1_ = Table.from_nested_object(obj_, [{:sort => true}, {:sort => true}])
+        assert_equal(Table.new(Structure.add(@labeled_axis_2).add(@labeled_axis_3),
+          :load => [nil, 1, 2, 4, nil, 3]), t1_)
+        t2_ = Table.from_nested_object(obj_, [{:sort => true}, {:sort => true}], :fill => :foo)
+        assert_equal(Table.new(Structure.add(@labeled_axis_2).add(@labeled_axis_3),
+          :load => [:foo, 1, 2, 4, :foo, 3]), t2_)
+      end
+
+
+      def test_to_level_2_labeled
+        t1_ = Table.new(Structure.add(@labeled_axis_2).add(@labeled_axis_3),
+          :load => [nil, 1, 2, 4, nil, 3])
+        assert_equal({'one' => {'red' => 1, 'white' => 2}, 'two' => {'white' => 3, 'blue' => 4}},
+          t1_.to_nested_object(:exclude_value => nil))
+        assert_equal({'one' => {'red' => 1, 'white' => 2, 'blue' => nil}, 'two' => {'red' => nil, 'white' => 3, 'blue' => 4}},
+          t1_.to_nested_object)
+      end
+
+
+      def test_from_empty_indexed
+        t1_ = Table.from_nested_object([])
+        assert_equal(Table.new(Structure.add(@indexed_axis_0)), t1_)
+      end
+
+
+      def test_to_empty_indexed
+        t1_ = Table.new(Structure.add(@indexed_axis_0))
+        assert_equal([], t1_.to_nested_object)
+      end
+
+
+      def test_from_level_1_start_0_indexed
+        obj_ = [2, 3]
+        t1_ = Table.from_nested_object(obj_)
+        assert_equal(Table.new(Structure.add(@indexed_axis_2), :load => [2,3]), t1_)
+      end
+
+
+      def test_to_level_1_start_0_indexed
+        t1_ = Table.new(Structure.add(@indexed_axis_2), :load => [2, 3])
+        assert_equal([2, 3], t1_.to_nested_object)
+      end
+
+
+      def test_from_level_1_start_1_indexed
+        obj_ = [nil] + (2..11).to_a
+        t1_ = Table.from_nested_object(obj_)
+        assert_equal(Table.new(Structure.add(@indexed_axis_10), :load => (2..11).to_a), t1_)
+      end
+
+
+      def test_to_level_1_start_1_indexed
+        t1_ = Table.new(Structure.add(@indexed_axis_10), :load => (2..11).to_a)
+        assert_equal([nil] + (2..11).to_a, t1_.to_nested_object)
+      end
+
+
+      def test_from_level_2_indexed
+        obj_ = [[nil, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], []]
+        t1_ = Table.from_nested_object(obj_)
+        assert_equal(Table.new(Structure.add(@indexed_axis_2).add(@indexed_axis_10),
+          :load => (2..11).to_a + ::Array.new(10)), t1_)
+      end
+
+
+      def test_to_level_2_indexed
+        t1_ = Table.new(Structure.add(@indexed_axis_2).add(@indexed_axis_10),
+          :load => (2..21).to_a)
+        assert_equal([[nil] + (2..11).to_a, [nil] + (12..21).to_a], t1_.to_nested_object)
+      end
+
+
+      def test_from_labeled_within_indexed
+        obj_ = [{:red => 1, :white => 2, :blue => 3}, {:red => 4, :white => 5}]
+        t1_ = Table.from_nested_object(obj_, [{:name => 'row'}, {:name => 'col', :sort => true}])
+        assert_equal(Table.new(Structure.add(@indexed_axis_2, 'row').add(@labeled_axis_3, 'col'),
+          :load => [3, 1, 2, nil, 4, 5]), t1_)
+      end
+
+
+      def test_to_labeled_within_indexed
+        t1_ = Table.new(Structure.add(@indexed_axis_2, 'row').add(@labeled_axis_3, 'col'),
+          :load => [3, 1, 2, 6, 4, 5])
+        assert_equal([{'red' => 1, 'white' => 2, 'blue' => 3}, {'red' => 4, 'white' => 5, 'blue' => 6}],
+          t1_.to_nested_object)
+      end
+
+
+      def test_from_indexed_within_labeled
+        obj_ = {:red => [1,2], :white => [3], :blue => [4,5]}
+        t1_ = Table.from_nested_object(obj_, [{:name => 'row', :sort => true}, {:name => 'col'}])
+        assert_equal(Table.new(Structure.add(@labeled_axis_3, 'row').add(@indexed_axis_2, 'col'),
+          :load => [4, 5, 1, 2, 3]), t1_)
+      end
+
+
+      def test_to_indexed_within_labeled
+        t1_ = Table.new(Structure.add(@labeled_axis_3, 'row').add(@indexed_axis_2, 'col'),
+          :load => [4, 5, 1, 2, 3, 6])
+        assert_equal({'red' => [1,2], 'white' => [3, 6], 'blue' => [4,5]},
+          t1_.to_nested_object)
+      end
+
+
+    end
+
+  end
+end

data/test/tc_reduce.rb

@@ -0,0 +1,161 @@
+# -----------------------------------------------------------------------------
+#
+# Table reduce 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 TestReduce < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def setup
+        @labeled_axis_2 = LabeledAxis.new([:one, :two])
+        @indexed_axis_10 = IndexedAxis.new(10,1)
+        @indexed_axis_0 = IndexedAxis.new(0)
+        @scalar_structure = Structure.new
+        @structure_1d = Structure.add(@indexed_axis_10)
+        @structure_2d = Structure.add(@indexed_axis_10).add(@labeled_axis_2)
+        @empty_structure = Structure.add(@indexed_axis_0)
+      end
+
+
+      def test_empty_reduce
+        t1_ = Table.new(@empty_structure)
+        assert_equal(nil, t1_.reduce(:+))
+        assert_equal(2, t1_.reduce(2, :+))
+        assert_equal(nil, t1_.reduce{ |s_, v_| flunk })
+        assert_equal(2, t1_.reduce(2){ |s_, v_| flunk })
+      end
+
+
+      def test_empty_reduce_with_position
+        t1_ = Table.new(@empty_structure)
+        assert_equal(nil, t1_.reduce_with_position{ |s_, v_, p_| flunk })
+        assert_equal(2, t1_.reduce_with_position(2){ |s_, v_, p_| flunk })
+      end
+
+
+      def test_scalar_reduce
+        t1_ = Table.new(@scalar_structure, :load => [2])
+        assert_equal(2, t1_.reduce(:+))
+        assert_equal(5, t1_.reduce(3, :+))
+        assert_equal(2, t1_.reduce{ |s_, v_| flunk })
+        assert_equal(5, t1_.reduce(3){ |s_, v_| s_ + v_ })
+      end
+
+
+      def test_scalar_reduce_with_position
+        t1_ = Table.new(@scalar_structure, :load => [2])
+        assert_equal(2, t1_.reduce_with_position{ |s_, v_, p_| flunk })
+        assert_equal(5, t1_.reduce_with_position(3){ |s_, v_, p_| assert_equal([], p_.coord_array); s_ + v_ })
+      end
+
+
+      def test_1d_reduce
+        t1_ = Table.new(@structure_1d, :load => (2..11).to_a)
+        assert_equal(65, t1_.reduce(:+))
+        assert_equal(165, t1_.reduce(100, :+))
+        assert_equal(65, t1_.reduce{ |s_, v_| s_ + v_ })
+        assert_equal(165, t1_.reduce(100){ |s_, v_| s_ + v_ })
+      end
+
+
+      def test_1d_reduce_with_position
+        t1_ = Table.new(@structure_1d, :load => (2..11).to_a)
+        label_ = 2
+        val_ = t1_.reduce_with_position do |s_, v_, p_|
+          assert_equal([label_], p_.coord_array)
+          label_ += 1
+          s_ + v_
+        end
+        assert_equal(65, val_)
+        label_ = 1
+        val_ = t1_.reduce_with_position(100) do |s_, v_, p_|
+          assert_equal([label_], p_.coord_array)
+          label_ += 1
+          s_ + v_
+        end
+        assert_equal(165, val_)
+      end
+
+
+      def test_2d_reduce
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        assert_equal(230, t1_.reduce(:+))
+        assert_equal(330, t1_.reduce(100, :+))
+        assert_equal(230, t1_.reduce{ |s_, v_| s_ + v_ })
+        assert_equal(330, t1_.reduce(100){ |s_, v_| s_ + v_ })
+      end
+
+
+      def test_2d_reduce_with_position
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        label1_ = 'two'
+        label2_ = 1
+        val_ = t1_.reduce_with_position do |s_, v_, p_|
+          assert_equal([label2_, label1_], p_.coord_array)
+          if label1_ == 'one'
+            label1_ = 'two'
+          else
+            label1_ = 'one'
+            label2_ += 1
+          end
+          s_ + v_
+        end
+        assert_equal(230, val_)
+        label1_ = 'one'
+        label2_ = 1
+        val_ = t1_.reduce_with_position(100) do |s_, v_, p_|
+          assert_equal([label2_, label1_], p_.coord_array)
+          if label1_ == 'one'
+            label1_ = 'two'
+          else
+            label1_ = 'one'
+            label2_ += 1
+          end
+          s_ + v_
+        end
+        assert_equal(330, val_)
+      end
+
+
+    end
+
+  end
+end