########################################################################
# #
# Test Script for finite-set.rb #
# #
########################################################################
require "rubyunit"
require "algebra/finite-set.rb"
include Algebra
=begin
o = Object.new
def o.call(x, y)
(x - y) % 3 == 0
end
s = Set[0, 1, 2, 3, 4, 5]
c = s.equiv_class(o)
p c == Set[Set[0, 3], Set[1, 4], Set[2, 5]]
exit
#p Set[Set[0,3],Set[5,2],Set[1,4]] == Set[Set[1,4],Set[5,2],Set[0,3]]
#exit
=end
class Rational;def inspect; to_s; end;end
class TestFiniteSet < Runit
include Algebra
def test_initialize #test for initialize
s = Set.new(0, "a", [1, 2])
assert(s.is_a?(Set))
end
def test_new_a #test for self.new_a
s = Set.new_a([0, "a", [1, 2]])
t = Set[0, "a", [1, 2]]
assert_equal(s, t)
end
def test_new_h #test for self.new_h
s = Set.new_h({0=>true, "a"=>true, [1, 2]=>true})
t = Set[0, "a", [1, 2]]
assert_equal(s, t)
end
def test_self_dot_empty_set #test for self.empty_set
assert_equal(Set.empty_set.size, 0)
end
def test_self_dot_phi #test for self.phi
assert_equal(Set.phi.size, 0)
end
def test_self_dot__bra #test for self.[]
s = Set[0, "a", [1, 2]]
assert_equal(s.size, 3)
end
def test_self_dot_singleton
assert_equal(Set.singleton(0), Set[0])
end
def test_shift
s = Set[0, 1, 2]
t = s.dup
x = t.shift
assert(s.has?(x))
assert(s > t)
end
def test_shift
s = Set[0, 1, 2]
t = s.dup
x = t.pick
assert(s.has?(x))
assert(s == t)
end
def test_phi
assert_equal(Set[1].phi, Set[])
end
def test_empty_set
assert_equal(Set[1].phi, Set[])
end
def test_singleton
assert_equal(Set[1].singleton(0), Set[0])
end
def test_singleton?
assert(Set[0].singleton?)
assert(!Set[].singleton?)
assert(!Set[0, 1].singleton?)
end
def test_empty? #test for empty?
assert(Set.phi.empty?)
end
def test_each #test for each
Set[0, "a", [1, 2]].each do |x|
assert([0, "a", [1, 2]].include?(x))
end
end
def test_separate
s = Set[0, 1, 2, 3, 4, 5]
t = s.separate{|x| x % 3 == 0}
assert(t.class, Set[0, 3])
end
def test_map_s
s = Set[0, 1, 2]
t = s.separate{|x| x ** 2}
assert(t.class, Set[0, 1, 4])
end
def test_dup #test for dup
a = Set[[0], [1], [2]]
b = a.dup
b.each do |x|
x.push x[0]
end
assert(a.id != b.id)
a.each do |x|
assert_equal(x.size, 2)
end
end
def test_push #test for push
s = Set[0, 1, 3]
s.push 2
assert_equal(s.size, 4)
s.push 3
assert_equal(s.size, 4)
end
def test_concat
s = Set[0, 1, 3]
s.concat Set[1, 2]
assert_equal(s, Set[0, 1, 2, 3])
end
def test_rehash #test for rehash
s = Set[[0], [1], [2]]
s.each do |x|
x[0] += 10
end
assert(s != Set[[10], [11], [12]])
s.rehash
assert(s == Set[[10], [11], [12]])
end
def test__equal #test for ==
assert(Set[0, 3, "a"] == Set[3, "a", 0])
assert(Set[0, 3, "a", 2] != Set[3, "a", 0])
assert(Set[0, 3, "a"] != Set[3, "a", 0, 2])
end
def test_include? #test for include?
assert(Set[0, 3, "a"].include?(0))
assert(!Set[0, 3, "a"].include?(1))
end
def test_has? #test for has?
assert(Set[0, 3, "a"].has?(0))
assert(!Set[0, 3, "a"].has?(1))
end
def test_incl? #test for incl?
assert(Set[0, 3, "a"].incl?(Set[0, 3]))
assert(Set[0, 3, "a"].incl?(Set["a", 0, 3]))
assert(! (Set[0, 3, "a"].incl?(Set["a", 0, 1])))
end
def test_isin? #test for isin?
assert(Set[0, 3].part_of?(Set[0, 3, "a"]))
assert(Set[0, 3, "a"].part_of?(Set["a", 0, 3]))
assert(! (Set[0, 3, "a"].part_of?(Set["a", 0, 1])))
end
def test_ge? #test for incl?
assert(Set[0, 3, "a"] >= Set[0, 3])
assert(Set[0, 3, "a"] >= Set["a", 0, 3])
assert(! (Set[0, 3, "a"] >= Set["a", 0, 1]))
end
def test_le? #test for isin?
assert(Set[0, 3] <= Set[0, 3, "a"])
assert(Set[0, 3, "a"] <= Set["a", 0, 3])
assert(! (Set[0, 3, "a"] <= Set["a", 0, 1]))
end
def test__gt? #test for incl?
assert(Set[0, 3, "a"] > Set[0, 3])
assert(! (Set[0, 3, "a"] > Set["a", 0, 3]))
assert(! (Set[0, 3, "a"] > Set["a", 0, 1]))
end
def test__lt? #test for isin?
assert(Set[0, 3] < Set[0, 3, "a"])
assert(! (Set[0, 3, "a"] < Set["a", 0, 3]))
assert(! (Set[0, 3, "a"] < Set["a", 0, 1]))
end
def test__plus #test for +
s = Set[0, 2, 4] + Set[1, 3]
assert_equal(s, Set[0, 1, 2, 3, 4])
end
def test__stroke #test for |
s = Set[0, 2, 4] | Set[1, 3]
assert_equal(s, Set[0, 1, 2, 3, 4])
end
def test_cup #test for cup
s = Set[0, 2, 4].cup Set[1, 3]
assert_equal(s, Set[0, 1, 2, 3, 4])
s = Set[*(0...15).to_a]
s2 = s.separate{|x| x % 2 == 0}
s3 = s.separate{|x| x % 3 == 0}
s5 = s.separate{|x| x % 5 == 0}
assert_equal(Set[s2, s3, s5].union, s - Set[1, 7, 11, 13])
end
def test__minus #test for -
assert_equal(Set[0, 2, 4] - Set[4, 2, 0], Set.phi)
assert_equal(Set[0, 2, 4] - Set[1, 3], Set[0, 2, 4])
assert_equal(Set[0, 1, 2, 4] - Set[1, 3], Set[0, 2, 4])
assert_equal(Set[0, 1, 2, 3] - Set[1, 3], Set[0, 2])
end
def test__amp #test for &
assert_equal(Set[0, 2, 4] & Set[4, 2, 0], Set[0, 2, 4])
assert_equal(Set[0, 2, 4] & Set[1, 3], Set.phi)
assert_equal(Set[0, 1, 2, 4] & Set[1, 3], Set[1])
assert_equal(Set[0, 1, 2, 3] & Set[1, 3], Set[1, 3])
end
def test_cap #test for cap
assert_equal(Set[0, 2, 4].cap(Set[4, 2, 0]), Set[0, 2, 4])
assert_equal(Set[0, 2, 4] .cap(Set[1, 3]), Set.phi)
assert_equal(Set[0, 1, 2, 4] .cap(Set[1, 3]), Set[1])
assert_equal(Set[0, 1, 2, 3] .cap(Set[1, 3]), Set[1, 3])
s = Set[*(0..30).to_a]
s2 = s.separate{|x| x % 2 == 0}
s3 = s.separate{|x| x % 3 == 0}
s5 = s.separate{|x| x % 5 == 0}
assert_equal(Set[s2, s3, s5].cap, Set[0, 30])
end
def test_each_pair #test for each_pair
s = Set.phi
Set[0, 1, 2].each_pair do |x, y|
s.push [x, y]
end
assert_equal(s, Set[[0, 1], [0, 2], [1, 2]])
end
def test_each_member #test for each_member
s = Set.phi
Set[0, 1, 2].each_member(1) do |a|
s.push Set[*a]
end
assert_equal(s, Set[Set[0], Set[1], Set[2]])
s = Set.phi
Set[0, 1, 2].each_member(2) do |a|
s.push Set[*a]
end
assert_equal(s, Set[Set[0, 1], Set[0, 2], Set[1, 2]])
s = Set.phi
Set[0, 1, 2].each_member(3) do |a|
s.push Set[*a]
end
assert_equal(s, Set[Set[0, 1, 2]])
end
def test_subset? #test for subset?
assert(Set[0, 1, 2].subset?(Set[0, 1, 2]))
assert(Set[0, 1].subset?(Set[0, 1, 2]))
assert(! Set[0, 1].subset?(Set[0, 3, 2]))
end
def test_each_subset #test for each_subset
s = Set.phi
Set.phi.each_subset do |t|
s.append! t
end
assert_equal(s.size, 2**0)
assert_equal(s, Set[Set.phi])
s = Set.phi
Set[0].each_subset do |t|
s.append! t
end
assert_equal(s.size, 2**1)
assert_equal(s, Set[Set[],Set[0]])
s = Set.phi
Set[0, 1].each_subset do |t|
s.append! t
end
assert_equal(s.size, 2**2)
assert_equal(s, Set[Set[], Set[1], Set[0], Set[1,0]])
s = Set.phi
Set[0, 1, 2].each_subset do |t|
s.append! t
end
assert_equal(s.size, 2**3)
assert_equal(s, Set[Set[],Set[1],Set[2],Set[0],
Set[1,2],Set[0,2],Set[0,1],Set[0,1,2]])
end
def test_each_non_trivial_subset #test for each_non_trivial_subset
s = Set.phi
Set.phi.each_non_trivial_subset do |t|
s.append! t
end
assert_equal(s.size, 2**0-1)
assert_equal(s, Set[])
s = Set.phi
Set[0].each_non_trivial_subset do |t|
s.append! t
end
assert_equal(s.size, 2**1-2)
assert_equal(s, Set[])
s = Set.phi
Set[0, 1].each_non_trivial_subset do |t|
s.append! t
end
assert_equal(s.size, 2**2-2)
assert_equal(s, Set[Set[1], Set[0]])
s = Set.phi
Set[0, 1, 2].each_non_trivial_subset do |t|
s.append! t
end
assert_equal(s.size, 2**3-2)
assert_equal(s, Set[Set[1],Set[2],Set[0],
Set[1,2],Set[0,2],Set[0,1],])
end
def test_power_set #test for power_set
assert_equal(Set.phi.power_set, Set[Set.phi])
assert_equal(Set[0].power_set, Set[Set[],Set[0]])
assert_equal(Set[0, 1].power_set, Set[Set[], Set[1], Set[0], Set[1,0]])
assert_equal(Set[0, 1, 2].power_set, Set[Set[],Set[1],Set[2],Set[0],
Set[1,2],Set[0,2],Set[0,1],Set[0,1,2]])
s = Set[true,false].power_set
assert_equal(s, Set[Set.phi, Set[true], Set[false], Set[true,false]])
assert(s != Set[Set.phi, Set[true]])
end
def test_each_product
s = Set.phi
Set[0, 1].each_product(Set[0, 1]) do |x, y|
s.push [x, y]
end
assert_equal(s, Set[[0,0], [0,1], [1,0], [1,1]])
end
def test_product #test for product
assert_equal(Set[0, 1].product(Set[0, 1]){ |x, y|
[x, y*2]
}, Set[[0,0], [0,2], [1,0], [1,2]])
end
def test__star #test for *
assert_equal(Set.phi * Set.phi, Set.phi)
assert_equal(Set.phi * Set[0], Set.phi)
assert_equal(Set[0] * Set[0], Set[[0,0]])
assert_equal(Set[0] * Set[0, 1], Set[[0,0], [0, 1]])
assert_equal(Set[0, 1] * Set[0, 1], Set[[0,0], [0,1], [1,0], [1,1]])
end
def test_equiv_class #test for equiv_class
o = Object.new
def o.call(x, y)
(x - y) % 3 == 0
end
s = Set[0, 1, 2, 3, 4, 5]
c = s.equiv_class(o)
assert_equal(c, Set[Set[0, 3], Set[1, 4], Set[2, 5]])
s = Set[0, 1, 2, 3, 4, 5]
def s.q(x, y)
(x - y) % 3 == 0
end
c = s.equiv_class(:q)
assert_equal(c, Set[Set[0, 3], Set[1, 4], Set[2, 5]])
s = Set[0, 1, 2, 3, 4, 5]
c = s.equiv_class{|a, b| (a - b) % 3 == 0}
assert_equal(c, Set[Set[0, 3], Set[1, 4], Set[2, 5]])
end
def test__slash #test for equiv_class
o = Object.new
def o.call(x, y)
(x - y) % 3 == 0
end
s = Set[0, 1, 2, 3, 4, 5]
c = s / o
assert_equal(c, Set[Set[0, 3], Set[1, 4], Set[2, 5]])
s = Set[0, 1, 2, 3, 4, 5]
def s.q(x, y)
(x - y) % 3 == 0
end
c = s / :q
assert_equal(c, Set[Set[0, 3], Set[1, 4], Set[2, 5]])
end
def test_to_a #test for to_a
assert_equal(Set[0, 1, 2].to_a, [0, 1, 2])
end
def test_to_ary #test for to_ary
a, b, c = Set[0, 1, 2]
assert(a == 0 && b == 1 && c == 2)
end
require "algebra/finite-map"
def test_power #test for power
a = Set[0, 1, 2]
b = Set[0, 1, 2]
s = a ** b
assert_equal(s.size, a.size**b.size)
a = Set[]
b = Set[0, 1, 2]
s = a ** b
assert_equal(s.size, a.size**b.size)
a = Set[0, 1, 2]
b = Set[]
s = a ** b
assert_equal(s.size, a.size**b.size)
end
def test_identity_map
a = Set[0, 1, 2]
b = Map[0=>0, 1=>1, 2=>2]
assert_equal(a.identity_map, b)
end
def test_surjections #test for surjections
a = Set[0, 1, 2]
b = Set[0, 1, 2]
s = a.surjections(b)
assert_equal(s.size, 3*2)
end
def test_injections0 #test for injections0
a = Set[0, 1, 2, 3]
b = Set[0, 1, 2]
s = a.injections0(b)
assert_equal(s.size, 24)
end
def test_injections #test for injections
a = Set[0, 1, 2, 3]
b = Set[0, 1, 2]
s = a.injections(b)
assert_equal(s.size, 24)
end
def test_bijections #test for bijections
assert_equal(Set[0, 1, 2].bijections(Set[0, 1, 2]).size, 6)
assert_equal(Set[0, 1, 2].bijections(Set[0, 1, 2, 3]).size, 0)
assert_equal(Set[0, 1, 2, 3].bijections(Set[0, 1, 2]).size, 0)
end
# def test_monotonic_series #test for monotonic_series
# assert_equal(0, 0)
# assert(true)
# end
end
Tests(TestFiniteSet)
syntax highlighted by Code2HTML, v. 0.9.1