maset 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.1.3"
+  gem "jeweler", "~> 1.8.3"
+  gem "simplecov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 ippei94da
+
+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.rdoc

@@ -0,0 +1,19 @@
+= maset
+
+Description goes here.
+
+== Contributing to maset
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 ippei94da. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "maset"
+  gem.homepage = "http://github.com/ippei94da/maset"
+  gem.license = "MIT"
+  gem.summary = %Q{Math Set: Mathematical library of set theory}
+  gem.description = %Q{This gem provides few libraries, which are Mapping and Categorize.}
+  gem.email = "ippei94da@gmail.com"
+  gem.authors = ["ippei94da"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+#  test.libs << 'test'
+#  test.pattern = 'test/**/test_*.rb'
+#  test.verbose = true
+#  test.rcov_opts << '--exclude "gems/*"'
+#end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "maset #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/categorizeYamlValues

@@ -0,0 +1,21 @@
+#! /usr/bin/ruby
+
+#USAGE: categorizeYamlValues.rb yaml_file
+#siteNames.rb などでサイト名を配列で表現した YAML から、
+#同じものをカテゴライズするのに使える。
+
+require "yaml"
+require "rubygems"
+gem "maset"
+require "maset/categorize.rb"
+
+cell_and_conf = YAML.load( ARGF ).to_a
+
+cell_and_conf.extend( Categorize )
+categories = cell_and_conf.categorize{ |a, b| a[1] == b[1] } 
+categories.each do |category|
+	puts category[0][1].join(",")
+	category.each do |i|
+		puts "  " + i[0]
+	end
+end

data/lib/maset/categorize.rb

@@ -0,0 +1,56 @@
+#要素を分類する。
+#
+#USAGE:
+#	基本的に、対象の Array に extend して使う。e.g.,
+#		arr = [ -2, -1, 0, 1, 2, 1]
+#		arr.extend( Categorize )
+#		arr.categorize #=> [ [-2], [-1], [0], [1, 1], [2] ],
+#		arr.categorize{ |a, b| a.abs == b.abs } #=> [ [-2, 2], [-1, 1, 1], [0] ]
+#
+#対象とするオブジェクトは、
+#「AとBが等価 かつ BとCが等価」と判定されたなら「AとCが等価」であることを前提としている。
+#たとえば、Float の近似判定のような場合にはうまくいかない可能性がある。
+#	a = 0.01
+#	b = 0.03
+#	c = 0.05
+#	a.equal_in_delta?( b, 0.03 ) => true
+#	b.equal_in_delta?( c, 0.03 ) => true
+#	c.equal_in_delta?( a, 0.03 ) => false
+#
+#生の配列で持っておいて必要なときに条件を渡されれば分類されたデータを返すという方式を採用。
+#	条件設定が柔軟で、オブジェクトの状態がシンプルで開発し易い。
+#	データが追加( initialize, push ) されるたびに適切なところに入れるという方式は、( push が速いかも？ )不適と判断した。
+#
+module Categorize
+	#分類する。
+	#等価判定が真になるもの同士で Array にまとめ、それらをまとめた 2重配列として返す。
+	#ブロックを渡された場合には、ブロックの条件で等価判定する。
+	#返り値の2重配列は、各カテゴリ内で元データの最も先頭に近かったデータの順番でソートされたものになる。
+	#e.g., [ 0, 1, 2, 1] ならば、[ [0], [1, 1], [2] ] のようになる。
+	def categorize
+		result = []
+		self.each do |item|
+			contained = nil #該当する category の Array 内 id
+			result.each_with_index do |category, i|
+				#category[0] と比較。
+				if block_given? #ブロックを渡されていたら
+					#そのブロックで等価判定
+					contained = i if yield( category[0], item )
+				else
+					#uniq と同じように eql? を使う
+					contained = i if category[0].eql?( item )
+				end
+				if contained
+					break
+				end
+			end
+			if contained
+				result[contained] << item
+			else
+				result << [item]
+			end
+		end
+		return result
+	end
+end
+

data/lib/maset/mapping.rb

@@ -0,0 +1,122 @@
+
+class Array
+	#引数と等価な全て要素のインデックスからなる配列を返す。
+	#find_all は要素を返すが、これはインデックスを返す点が異なる。
+	#e.g., [ 10, 20, 30 ].find_all_indices{ |i| i < 25 } #=> [ 0, 1 ]
+	def find_all_indices
+		results = []
+		self.each_with_index do |elem, i|
+			results << i if yield( elem )
+		end
+		results
+	end
+
+end
+
+#
+#要素同士の対応を扱うモジュール。
+module Mapping
+
+	#For module methods
+
+	#左のコンテナに注目し、右のコンテナにある条件を満たすインデックス全てを
+	#入れた配列を返す。
+	#等価なものを探すことなどに使える。
+	#右のコンテナに等価なものがなければ空配列が入る。
+	#e.g., left  = ['a', 'b', 'c', 'd']
+	#      right = ['b', 'c', 'a', 'a']
+	#      のとき、
+	#      self.left_to_right(left, right) #=> [ [2, 3], [0], [1], [] ]
+	#必ずブロックが渡されることを前提とする。
+	#ブロックをたとえば { |i, j| i == j } とすれば、
+	#left, right それぞれに由来する要素 i, j を == 演算で等価判定していることになる。
+	#ブロックに渡すのは等価判定でなくても構わない。
+	def self.map( left, right )
+		size = left.size
+		results = Array.new( size, [] )
+		size.times do |n|
+			results[n] = right.find_all_indices{ |i| yield( i, left[n] )  }
+		end
+		results
+	end
+
+	#2つのコンテナが一対一対応していれば true、そうでなければ false
+	#自分と自分でも多対多の対応になる可能性があり、その場合は false
+	def self.map?(left, right)
+		return true  if ((left.size == 0 ) && (right.size == 0))
+		return false if ((left.size == 0 ) || (right.size == 0)) #どちらかが 0 でどちらかが非0
+
+		l2r = self.map(left, right){ |i, j| yield( i, j ) }
+		r2l = self.map(right, left){ |i, j| yield( i, j ) }
+		result = true
+		result = false if ( l2r.max_by{|i| i.size }.size != 1 )
+		result = false if ( l2r.min_by{|i| i.size }.size != 1 )
+		result = false if ( r2l.max_by{|i| i.size }.size != 1 )
+		result = false if ( r2l.min_by{|i| i.size }.size != 1 )
+		#max_by, min_by は要素を返すため、それに操作を改めて加えてサイズを出す。
+		result
+	end
+
+	#map? よりもゆるく、多対多でも等しい要素の数が同じであれば true.
+	#e.g.,
+	#	a0 = ['b', 'c', 'a', 'a']
+	#	a1 = ['a', 'a', 'b', 'c']
+	#	のとき、Mapping::corresponding?( a0, a1 ) #=> true
+	def self.corresponding?( left, right )
+		return false if ( left.size != right.size )
+
+		l_indices = Mapping::map( left , right ){ |a, b| yield( a, b ) }
+		r_indices = Mapping::map( right, left  ){ |a, b| yield( a, b ) }
+		#p r_indices; exit
+		l_indices.size.times do |i|
+			results = []
+			return false if l_indices[i].empty? #対応が空のものがあれば false 確定。
+			l_indices[i].each do |x| #左の i 番要素は 右へのインデックスの配列なので、それを each
+				return false if l_indices[i].size != r_indices[x].size #対応の数が異なれば false。この条件には 右側が空であることも含まれる。
+				r_indices[x].each do |y| #対応する右の要素は、左へのインデックスの配列なので、それを each
+					results << l_indices[y] #さらに左の要素で、反射して対応する全てが得られる。
+				end
+			end
+			#p results.flatten.uniq
+			#p l_indices[i]
+			#全部 [] のときも true になっちまう。
+			#対応がない場合も考えないとなー。
+			#どれか、どちらかが一つでも空対応のときは false でいいか。
+			return false if ( results.flatten.uniq != l_indices[i] )
+		end
+		return true
+
+		#l_hash = Hash.new
+		#r_hash = Hash.new
+		#left.uniq.each do |i|
+		#	l_hash[ i ] = left .select{ |j| yield( i, j ) }.size
+		#	r_hash[ i ] = right.select{ |j| yield( i, j ) }.size
+		#end
+		#p l_hash, r_hash
+		#return l_hash == r_hash
+	end
+
+	#For instance methods
+
+	#クラスに include されたときに Mapping::corresponding? をクラスメソッドとして使えるようにしたもの。
+	def corresponding?( other )
+		Mapping::corresponding?( self, other ){ |i, j| yield( i, j ) }
+	end
+
+	#自分から引数のコンテナへの写像と考えたときの、対応するインデックスを配列して返す。
+	def map_to(other)
+		Mapping::map(self, other){ |i, j| yield( i, j ) }
+	end
+
+	#引数のコンテナから自分数への写像と考えたときの、対応するインデックスを配列して返す。
+	def map_from(other)
+		Mapping::map(other, self){ |i, j| yield( i, j ) }
+	end
+
+	#引数のコンテナと一対一で対応すれば true, そうでなければ false。
+	#自分と比較しても多対多の対応になる可能性があり、その場合は false
+	def map?(other)
+		Mapping::map?(self, other){ |i, j| yield( i, j ) }
+	end
+
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'maset'
+
+class Test::Unit::TestCase
+end

data/test/test_categorize.rb

@@ -0,0 +1,26 @@
+#! /usr/bin/ruby
+
+require 'test/unit'
+require 'maset/categorize.rb'
+
+#assert_equal(correctVal, @f.bar)
+
+class TC_Categorize < Test::Unit::TestCase
+	#Array への extend として機能するか？
+	def test_module_extend
+		arr = [ -2, -1, 0, 1, 2, 1]
+		arr.extend( Categorize )
+		assert_equal( [ [-2], [-1], [0], [1, 1], [2] ], arr.categorize )
+
+		#ブロック渡しが機能するか？
+		assert_equal( [ [-2, 2], [-1, 1, 1], [0] ],
+			arr.categorize{ |a, b| a.abs == b.abs }
+		)
+
+		##push してできるか
+		#arr.push( 0 )
+		#assert_equal( [ [-2], [-1], [0, 0], [1, 1], [2] ], arr.categorize )
+	end
+
+end
+

data/test/test_mapping.rb

@@ -0,0 +1,205 @@
+#! /usr/bin/ruby
+
+require 'test/unit'
+require 'maset/mapping.rb'
+
+class TC_Array < Test::Unit::TestCase
+	def setup
+		@a0 = ['a', 'b', 'c', 'b', ]
+		@a1 = [ 1, 2, 3, -2 ]
+	end
+
+	def test_find_all_indices
+		assert_equal([0],   @a0.find_all_indices{|i| i == 'a' })
+		assert_equal([1,3], @a0.find_all_indices{|i| i == 'b' })
+		assert_equal([2],   @a0.find_all_indices{|i| i == 'c' })
+		assert_equal([],    @a0.find_all_indices{|i| i == 'd' })
+
+		assert_equal([0,3], @a1.find_all_indices{ |i| i < 2 } )
+		assert_equal([0,1,3], @a1.find_all_indices{ |i| i <= 2 } )
+		assert_equal([1, 3], @a1.find_all_indices{ |i| i.abs == 2 } )
+	end
+
+end
+
+class Array
+	include Mapping
+end
+
+class TC_Mapping < Test::Unit::TestCase
+	def setup
+		@a0 = ['a', 'b', 'c', 'd']
+		@a1 = ['b', 'c', 'a', 'a']
+		@a2 = ['b', 'c', 'a', 'd']
+		@a3 = ['a', 'a', 'b', 'c']
+		@a4 = ['a', 'b', 'c']
+		@b0 = [  1,  2,  3 ]
+		@b1 = [ -2, -3, -1 ]
+		@b2 = [ -1,  2,  3 ]
+
+		@c0 = [ 1, 2, 3, 3]
+		@c1 = [-3,-3,-1,-2]
+		@c2 = [-1,-3,-3,-3]
+		@c3 = [-1,-4,-3,-3]
+		@c4 = [-1,-1,-3,-3]
+	end
+
+	def test_self_map
+		assert_equal( [[2,3],[0],[1],[]], Mapping::map(@a0, @a1){ |i, j| i == j } )
+		assert_equal( [[0],[1],[2],[2]] , Mapping::map(@a1, @a2){ |i, j| i == j } )
+		assert_equal( [[1],[2],[0],[3]] , Mapping::map(@a2, @a0){ |i, j| i == j } )
+		assert_equal( [[1],[2],[0],[0]] , Mapping::map(@a1, @a0){ |i, j| i == j } )
+		assert_equal( [[0],[1],[2,3],[]], Mapping::map(@a2, @a1){ |i, j| i == j } )
+		assert_equal( [[2],[0],[1],[3]] , Mapping::map(@a0, @a2){ |i, j| i == j } )
+		assert_equal( [[0],[1],[2],[]]  , Mapping::map(@a0, @a4){ |i, j| i == j } )
+		assert_equal( [[2],[0],[1]]     , Mapping::map(@b0, @b1){ |i, j| i == -j } )
+		assert_equal( [[0],[],[]]       , Mapping::map(@b0, @b2){ |i, j| i == -j } )
+	end
+
+	def test_self_map?
+		assert_equal(true , Mapping::map?(@a0, @a0){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a0, @a1){ |i, j| i == j } )
+		assert_equal(true , Mapping::map?(@a0, @a2){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a1, @a0){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a1, @a1){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a1, @a2){ |i, j| i == j } )
+		assert_equal(true , Mapping::map?(@a2, @a0){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a2, @a1){ |i, j| i == j } )
+		assert_equal(true , Mapping::map?(@a2, @a2){ |i, j| i == j } )
+		assert_equal(true , Mapping::map?([] , [] ){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?(@a0, [] ){ |i, j| i == j } )
+		assert_equal(false, Mapping::map?([] , @a0){ |i, j| i == j } )
+
+		assert_equal(true , Mapping::map?(@b0, @b1){ |i, j| i == -j })
+		assert_equal(false, Mapping::map?(@b0, @b2){ |i, j| i == -j })
+	end
+
+	def test_self_correspond?
+		assert_equal(true , Mapping::corresponding?(@a0, @a0){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a0, @a1){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a0, @a2){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a0, @a3){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a0, @a4){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a1, @a0){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a1, @a1){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a1, @a2){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a1, @a3){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a1, @a4){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a2, @a0){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a2, @a1){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a2, @a2){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a2, @a3){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a2, @a4){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a3, @a0){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a3, @a1){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a3, @a2){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@a3, @a3){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@a3, @a4){ |i, j| i == j })
+		assert_equal(true , Mapping::corresponding?(@b0, @b1){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@b0, @b2){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c0, @c1){ |i, j| i == j })
+		assert_equal(false, Mapping::corresponding?(@c0, @c0){ |i, j| i == -j })
+		assert_equal(true , Mapping::corresponding?(@c0, @c1){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c0, @c2){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c0, @c3){ |i, j| i == -j })
+		assert_equal(true , Mapping::corresponding?(@c1, @c0){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c1, @c1){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c1, @c2){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c1, @c3){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c2, @c0){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c2, @c1){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c2, @c2){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c2, @c3){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c3, @c0){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c3, @c1){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c3, @c2){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c3, @c3){ |i, j| i == -j })
+		assert_equal(false, Mapping::corresponding?(@c2, @c4){ |i, j| i == -j })
+	end
+
+	def test_correspond?
+		assert_equal(true , @a0.corresponding?( @a0){ |i, j| i == j })
+		assert_equal(false, @a0.corresponding?( @a1){ |i, j| i == j })
+		assert_equal(true , @a0.corresponding?( @a2){ |i, j| i == j })
+		assert_equal(false, @a0.corresponding?( @a3){ |i, j| i == j })
+		assert_equal(false, @a0.corresponding?( @a4){ |i, j| i == j })
+		assert_equal(false, @a1.corresponding?( @a0){ |i, j| i == j })
+		assert_equal(true , @a1.corresponding?( @a1){ |i, j| i == j })
+		assert_equal(false, @a1.corresponding?( @a2){ |i, j| i == j })
+		assert_equal(true , @a1.corresponding?( @a3){ |i, j| i == j })
+		assert_equal(false, @a1.corresponding?( @a4){ |i, j| i == j })
+		assert_equal(true , @a2.corresponding?( @a0){ |i, j| i == j })
+		assert_equal(false, @a2.corresponding?( @a1){ |i, j| i == j })
+		assert_equal(true , @a2.corresponding?( @a2){ |i, j| i == j })
+		assert_equal(false, @a2.corresponding?( @a3){ |i, j| i == j })
+		assert_equal(false, @a2.corresponding?( @a4){ |i, j| i == j })
+		assert_equal(false, @a3.corresponding?( @a0){ |i, j| i == j })
+		assert_equal(true , @a3.corresponding?( @a1){ |i, j| i == j })
+		assert_equal(false, @a3.corresponding?( @a2){ |i, j| i == j })
+		assert_equal(true , @a3.corresponding?( @a3){ |i, j| i == j })
+		assert_equal(false, @a3.corresponding?( @a4){ |i, j| i == j })
+		assert_equal(true , @b0.corresponding?( @b1){ |i, j| i == -j })
+		assert_equal(false, @b0.corresponding?( @b2){ |i, j| i == -j })
+		assert_equal(false, @c0.corresponding?( @c1){ |i, j| i == j })
+		assert_equal(false, @c0.corresponding?( @c0){ |i, j| i == -j })
+		assert_equal(true , @c0.corresponding?( @c1){ |i, j| i == -j })
+		assert_equal(false, @c0.corresponding?( @c2){ |i, j| i == -j })
+		assert_equal(false, @c0.corresponding?( @c3){ |i, j| i == -j })
+		assert_equal(true , @c1.corresponding?( @c0){ |i, j| i == -j })
+		assert_equal(false, @c1.corresponding?( @c1){ |i, j| i == -j })
+		assert_equal(false, @c1.corresponding?( @c2){ |i, j| i == -j })
+		assert_equal(false, @c1.corresponding?( @c3){ |i, j| i == -j })
+		assert_equal(false, @c2.corresponding?( @c0){ |i, j| i == -j })
+		assert_equal(false, @c2.corresponding?( @c1){ |i, j| i == -j })
+		assert_equal(false, @c2.corresponding?( @c2){ |i, j| i == -j })
+		assert_equal(false, @c2.corresponding?( @c3){ |i, j| i == -j })
+		assert_equal(false, @c3.corresponding?( @c0){ |i, j| i == -j })
+		assert_equal(false, @c3.corresponding?( @c1){ |i, j| i == -j })
+		assert_equal(false, @c3.corresponding?( @c2){ |i, j| i == -j })
+		assert_equal(false, @c3.corresponding?( @c3){ |i, j| i == -j })
+		assert_equal(false, @c2.corresponding?( @c4){ |i, j| i == -j })
+	end
+
+	def test_map_to
+		assert_equal([[2,3],[0],[1],[]], @a0.map_to(@a1){ |i, j| i == j })
+		assert_equal([[0],[1],[2],[2]],  @a1.map_to(@a2){ |i, j| i == j })
+		assert_equal([[1],[2],[0],[3]],  @a2.map_to(@a0){ |i, j| i == j })
+		assert_equal([[1],[2],[0],[0]],  @a1.map_to(@a0){ |i, j| i == j })
+		assert_equal([[0],[1],[2,3],[]], @a2.map_to(@a1){ |i, j| i == j })
+		assert_equal([[2],[0],[1],[3]],  @a0.map_to(@a2){ |i, j| i == j })
+		assert_equal( [[2], [0], [1]], @b0.map_to(@b1){ |i, j| i == -j })
+		assert_equal( [[0], [], []]  , @b0.map_to(@b2){ |i, j| i == -j })
+	end
+
+	def test_map_from
+		assert_equal([[2,3],[0],[1],[]], @a1.map_from(@a0){ |i, j| i == j })
+		assert_equal([[0],[1],[2],[2]],  @a2.map_from(@a1){ |i, j| i == j })
+		assert_equal([[1],[2],[0],[3]],  @a0.map_from(@a2){ |i, j| i == j })
+		assert_equal([[1],[2],[0],[0]],  @a0.map_from(@a1){ |i, j| i == j })
+		assert_equal([[0],[1],[2,3],[]], @a1.map_from(@a2){ |i, j| i == j })
+		assert_equal([[2],[0],[1],[3]],  @a2.map_from(@a0){ |i, j| i == j })
+		assert_equal( [[1], [2], [0]] ,  @b0.map_from(@b1){ |i, j| i == -j })
+		assert_equal( [[0], [], []]   ,  @b0.map_from(@b2){ |i, j| i == -j })
+	end
+
+	def test_map?
+		assert_equal(false, @a0.map?(@a1){ |i, j| i == j })
+		assert_equal(false, @a1.map?(@a2){ |i, j| i == j })
+		assert_equal(true , @a2.map?(@a0){ |i, j| i == j })
+		assert_equal(false, @a1.map?(@a0){ |i, j| i == j })
+		assert_equal(false, @a2.map?(@a1){ |i, j| i == j })
+		assert_equal(true , @a0.map?(@a2){ |i, j| i == j })
+
+		assert_equal( true , @b0.map?(@b1){ |i, j| i == -j })
+		assert_equal( false, @b0.map?(@b2){ |i, j| i == -j })
+	end
+
+	def test_module_extend 
+		a0 = ['a', 'b', 'c', 'd']
+		a0.extend( Mapping )
+		assert_equal(false, a0.map?( @a1 ){ |i, j| i == j })
+		assert_equal(true , a0.map?( @a2 ){ |i, j| i == j })
+	end
+
+end
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: maset
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- ippei94da
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides few libraries, which are Mapping and Categorize.
+email: ippei94da@gmail.com
+executables:
+- categorizeYamlValues
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/categorizeYamlValues
+- lib/maset.rb
+- lib/maset/categorize.rb
+- lib/maset/mapping.rb
+- test/helper.rb
+- test/test_categorize.rb
+- test/test_mapping.rb
+homepage: http://github.com/ippei94da/maset
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -165794623
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: ! 'Math Set: Mathematical library of set theory'
+test_files: []