ntable 0.1.0

data/test/tc_axes.rb

@@ -0,0 +1,124 @@
+# -----------------------------------------------------------------------------
+#
+# Axis object 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 TestAxes < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def test_labeled_axis_size
+        axis_ = LabeledAxis.new([:one, :two])
+        assert_equal(2, axis_.size)
+      end
+
+
+      def test_labeled_axis_label_to_index
+        axis_ = LabeledAxis.new([:one, :two])
+        assert_equal(0, axis_.label_to_index(:one))
+        assert_equal(1, axis_.label_to_index(:two))
+        assert_nil(axis_.label_to_index(:three))
+      end
+
+
+      def test_labeled_axis_index_to_label
+        axis_ = LabeledAxis.new([:one, :two])
+        assert_equal('one', axis_.index_to_label(0))
+        assert_equal('two', axis_.index_to_label(1))
+        assert_nil(axis_.index_to_label(2))
+      end
+
+
+      def test_labeled_axis_equality
+        axis1_ = LabeledAxis.new([:one, :two])
+        axis2_ = LabeledAxis.new([:one, :two])
+        axis3_ = LabeledAxis.new([:one, :three])
+        assert_equal(axis1_, axis2_)
+        refute_equal(axis1_, axis3_)
+      end
+
+
+      def test_labeled_axis_empty
+        axis_ = LabeledAxis.new([])
+        assert_equal(0, axis_.size)
+      end
+
+
+      def test_indexed_axis_size
+        axis_ = IndexedAxis.new(2)
+        assert_equal(2, axis_.size)
+      end
+
+
+      def test_indexed_axis_label_to_index
+        axis_ = IndexedAxis.new(2, 4)
+        assert_equal(0, axis_.label_to_index(4))
+        assert_equal(1, axis_.label_to_index(5))
+        assert_nil(axis_.label_to_index(3))
+      end
+
+
+      def test_indexed_axis_index_to_label
+        axis_ = IndexedAxis.new(2, 4)
+        assert_equal(4, axis_.index_to_label(0))
+        assert_equal(5, axis_.index_to_label(1))
+        assert_nil(axis_.index_to_label(2))
+      end
+
+
+      def test_indexed_axis_equality
+        axis1_ = IndexedAxis.new(2, 4)
+        axis2_ = IndexedAxis.new(2, 4)
+        axis3_ = IndexedAxis.new(2, 3)
+        assert_equal(axis1_, axis2_)
+        refute_equal(axis1_, axis3_)
+      end
+
+
+      def test_indexed_axis_empty
+        axis_ = IndexedAxis.new(0)
+        assert_equal(0, axis_.size)
+      end
+
+
+    end
+
+  end
+end

data/test/tc_basic_values.rb

@@ -0,0 +1,129 @@
+# -----------------------------------------------------------------------------
+#
+# Basic table values 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 TestBasicValues < ::MiniTest::Unit::TestCase  # :nodoc:
+
+
+      def setup
+        @labeled_axis = LabeledAxis.new([:red, :white, :blue])
+        @indexed_axis = IndexedAxis.new(10)
+        @structure = Structure.new.add(@indexed_axis, :row).add(@labeled_axis, :column)
+      end
+
+
+      def test_fill
+        table_ = Table.new(@structure, :fill => 1)
+        assert_equal(1, table_.get(0, :red))
+        assert_equal(1, table_.get(5, :blue))
+      end
+
+
+      def test_load_and_get_from_array
+        table_ = Table.new(@structure, :load => (0..29).to_a)
+        assert_equal(0, table_.get(0, :red))
+        assert_equal(17, table_.get(5, :blue))
+      end
+
+
+      def test_load_and_get_from_hash
+        table_ = Table.new(@structure, :load => (0..29).to_a)
+        assert_equal(0, table_.get(:row => 0, :column => :red))
+        assert_equal(17, table_.get(:row => 5, :column => :blue))
+      end
+
+
+      def test_load_bang
+        table_ = Table.new(@structure)
+        table_.load!((0..16).to_a)
+        assert_equal(0, table_.get(0, :red))
+        assert_equal(16, table_.get(5, :white))
+        assert_nil(table_.get(5, :blue))
+      end
+
+
+      def test_set_from_array
+        table_ = Table.new(@structure)
+        table_.set!(0, :red, "foo")
+        table_[5, :blue] = "bar"
+        assert_equal("foo", table_.get(0, :red))
+        assert_equal("bar", table_[5, :blue])
+        assert_nil(table_.get(5, :white))
+      end
+
+
+      def test_set_from_hash
+        table_ = Table.new(@structure)
+        table_.set!({:row => 0, :column => :red}, "foo")
+        table_[:column => :blue, :row => 5] = "bar"
+        assert_equal("foo", table_.get(0, :red))
+        assert_equal("bar", table_[5, :blue])
+        assert_nil(table_.get(5, :white))
+      end
+
+
+      def test_load_no_axes
+        t1_ = Table.new(Structure.new, :load => [1])
+        assert_equal(1, t1_.get)
+      end
+
+
+      def test_empty_equality
+        assert_equal(Table.new(Structure.new), Table.new(Structure.new))
+      end
+
+
+      def test_basic_equality
+        t1_ = Table.new(@structure, :fill => 0)
+        t2_ = Table.new(@structure, :fill => 0)
+        assert_equal(t1_, t2_)
+        t1_[:row => 0, :column => :red] = 1
+        refute_equal(t1_, t2_)
+        t2_[:row => 0, :column => :red] = 1
+        assert_equal(t1_, t2_)
+      end
+
+
+    end
+
+  end
+end

data/test/tc_decompose.rb

@@ -0,0 +1,104 @@
+# -----------------------------------------------------------------------------
+#
+# Table decomposition 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 TestDecompose < ::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_row = Structure.add(@labeled_axis_2)
+        @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_scalar_decompose
+        t1_ = Table.new(@scalar_structure, :load => [:foo])
+        t2_ = t1_.decompose([])
+        assert_equal(0, t2_.dim)
+        assert_equal(1, t2_.size)
+        assert_equal(t1_, t2_.get)
+      end
+
+
+      def test_1d_decompose_inner
+        t1_ = Table.new(@structure_1d, :load => (2..11).to_a)
+        t2_ = t1_.decompose([0])
+        assert_equal(0, t2_.dim)
+        assert_equal(1, t2_.size)
+        assert_equal(t1_, t2_.get)
+      end
+
+
+      def test_1d_decompose_outer
+        t1_ = Table.new(@structure_1d, :load => (2..11).to_a)
+        t2_ = t1_.decompose([])
+        assert_equal(Table.new(@scalar_structure, :load => [2]), t2_.get(1))
+        assert_equal(Table.new(@scalar_structure, :load => [3]), t2_.get(2))
+      end
+
+
+      def test_2d_decompose
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        t2_ = t1_.decompose([1])
+        assert_equal(Table.new(@structure_row, :load => [2, 3]), t2_.get(1))
+        assert_equal(Table.new(@structure_row, :load => [4, 5]), t2_.get(2))
+      end
+
+
+      def test_2d_decompose_reduce
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        t2_ = t1_.decompose_reduce([1], :*)
+        assert_equal(6, t2_.get(1))
+        assert_equal(20, t2_.get(2))
+      end
+
+
+    end
+
+  end
+end

data/test/tc_enumeration.rb

@@ -0,0 +1,238 @@
+# -----------------------------------------------------------------------------
+#
+# Table enumeration (each/map) 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 TestEnumeration < ::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_2d = Structure.add(@indexed_axis_10).add(@labeled_axis_2)
+        @empty_structure = Structure.add(@indexed_axis_0)
+      end
+
+
+      def test_scalar_each
+        t1_ = Table.new(@scalar_structure, :load => [:foo])
+        size_ = 0
+        t1_.each do |v_|
+          assert_equal(:foo, v_)
+          size_ += 1
+        end
+        assert_equal(1, size_)
+      end
+
+
+      def test_scalar_each_with_position
+        t1_ = Table.new(@scalar_structure, :load => [:foo])
+        size_ = 0
+        t1_.each_with_position do |v_, p_|
+          assert_equal(:foo, v_)
+          assert_equal([], p_.coord_array)
+          size_ += 1
+        end
+        assert_equal(1, size_)
+      end
+
+
+      def test_scalar_map
+        t1_ = Table.new(@scalar_structure, :load => [1])
+        t2_ = t1_.map do |v_|
+          v_ * 2
+        end
+        assert_equal(2, t2_.get)
+      end
+
+
+      def test_scalar_map_with_position
+        t1_ = Table.new(@scalar_structure, :load => [1])
+        t2_ = t1_.map_with_position do |v_, p_|
+          assert_equal([], p_.coord_array)
+          v_ * 2
+        end
+        assert_equal(2, t2_.get)
+      end
+
+
+      def test_scalar_map_bang
+        t1_ = Table.new(@scalar_structure, :load => [1])
+        t1_.map! do |v_|
+          v_ * 2
+        end
+        assert_equal(2, t1_.get)
+      end
+
+
+      def test_scalar_map_with_position_bang
+        t1_ = Table.new(@scalar_structure, :load => [1])
+        t1_.map_with_position! do |v_, p_|
+          assert_equal([], p_.coord_array)
+          v_ * 2
+        end
+        assert_equal(2, t1_.get)
+      end
+
+
+      def test_2d_each
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        size_ = 2
+        t1_.each do |v_|
+          assert_equal(size_, v_)
+          size_ += 1
+        end
+        assert_equal(22, size_)
+      end
+
+
+      def test_2d_each_with_position
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        size_ = 2
+        label1_ = 'one'
+        label2_ = 1
+        t1_.each_with_position do |v_, p_|
+          assert_equal([label2_, label1_], p_.coord_array)
+          assert_equal(size_, v_)
+          size_ += 1
+          if label1_ == 'one'
+            label1_ = 'two'
+          else
+            label1_ = 'one'
+            label2_ += 1
+          end
+        end
+        assert_equal(22, size_)
+      end
+
+
+      def test_2d_map
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        t2_ = t1_.map do |v_|
+          v_ * 2
+        end
+        assert_equal(4, t2_.get(1, :one))
+        assert_equal(6, t2_.get(1, :two))
+        assert_equal(42, t2_.get(10, :two))
+      end
+
+
+      def test_2d_map_with_position
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        label1_ = 'one'
+        label2_ = 1
+        t2_ = t1_.map_with_position do |v_, p_|
+          assert_equal([label2_, label1_], p_.coord_array)
+          if label1_ == 'one'
+            label1_ = 'two'
+          else
+            label1_ = 'one'
+            label2_ += 1
+          end
+          v_ * 2
+        end
+        assert_equal(4, t2_.get(1, :one))
+        assert_equal(6, t2_.get(1, :two))
+        assert_equal(42, t2_.get(10, :two))
+      end
+
+
+      def test_2d_map_bang
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        t1_.map! do |v_|
+          v_ * 2
+        end
+        assert_equal(4, t1_.get(1, :one))
+        assert_equal(6, t1_.get(1, :two))
+        assert_equal(42, t1_.get(10, :two))
+      end
+
+
+      def test_2d_map_with_position_bang
+        t1_ = Table.new(@structure_2d, :load => (2..21).to_a)
+        label1_ = 'one'
+        label2_ = 1
+        t1_.map_with_position! do |v_, p_|
+          assert_equal([label2_, label1_], p_.coord_array)
+          if label1_ == 'one'
+            label1_ = 'two'
+          else
+            label1_ = 'one'
+            label2_ += 1
+          end
+          v_ * 2
+        end
+        assert_equal(4, t1_.get(1, :one))
+        assert_equal(6, t1_.get(1, :two))
+        assert_equal(42, t1_.get(10, :two))
+      end
+
+
+      def test_empty
+        t1_ = Table.new(@empty_structure)
+        t1_.each do |v_|
+          flunk
+        end
+        t1_.each_with_position do |v_, p_|
+          flunk
+        end
+        t1_.map do |v_|
+          flunk
+        end
+        t1_.map_with_position do |v_, p_|
+          flunk
+        end
+        t1_.map! do |v_|
+          flunk
+        end
+        t1_.map_with_position! do |v_, p_|
+          flunk
+        end
+        pass
+      end
+
+
+    end
+
+  end
+end