ConstraintSolver 0.1

data/test/GraphUtilsTest.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'GraphUtils'
+require 'set'
+
+module GraphUtils
+    class BipartiteGraphTest < Test::Unit::TestCase
+	def testConstructor
+	    assert_raise(ArgumentError) { BipartiteGraph.new }
+	    assert_raise(ArgumentError) { BipartiteGraph.new(nil, nil, nil) }
+	    assert_raise(ArgumentError) { BipartiteGraph.new(Set.new, Set.new, Hash.new) }
+	    assert_nothing_raised { BipartiteGraph.new(["a"].to_set, [1].to_set, { "a" => [1] }) }
+	end
+
+	def testMaximumMatchingCovering
+	    graph = BipartiteGraph.new(["x","y","z"].to_set, [1,2,3].to_set,
+		  { "x" => [1,3].to_set, "y" => [2,3].to_set, "z" => [2].to_set })
+	    matching = graph.maximum_matching
+	    assert_equal(3, matching.size)
+	    assert_equal(1, matching["x"])
+	    assert_equal(3, matching["y"])
+	    assert_equal(2, matching["z"])
+	end
+
+	def testMaximumMatchingNotCovering
+	    graph = BipartiteGraph.new(["x","y","z"].to_set, [1,2].to_set,
+		  { "x" => [1,2].to_set, "y" => [1,2].to_set, "z" => [1,2].to_set })
+	    matching = graph.maximum_matching
+	    assert_equal(2, matching.size)
+	end
+
+	def testMaximumMatchingRecalc
+	    graph = BipartiteGraph.new(["x","y","z"].to_set, [1,2,3,4].to_set,
+		  { "x" => [1,2,3].to_set, "y" => [2,3,4].to_set, "z" => [2,3].to_set })
+	    matching = graph.maximum_matching
+	    assert_equal(true, matching.eql?(graph.maximum_matching))
+	    graph.e["x"] = [2,3].to_set
+	    matching = graph.maximum_matching
+	    assert_equal(3, matching.size)
+	    assert_equal(2, matching["x"])
+	    assert_equal(4, matching["y"])
+	    assert_equal(3, matching["z"])
+	end
+
+	def testRemovableValues
+	    graph = BipartiteGraph.new(["x","y","z"].to_set, [1,2,3].to_set,
+		  { "x" => [1,3].to_set, "y" => [2,3].to_set, "z" => [2].to_set })
+	    matching = graph.maximum_matching
+	    assert_equal({ "x" => [ 3 ].to_set, "y" => [ 2 ].to_set },
+			 graph.removable_values(matching))
+	end
+    end
+
+    class GraphUtilsTest < Test::Unit::TestCase
+	def testStronglyConnectedComponents
+	    assert_equal([],
+			 GraphUtils::strongly_connected_components([ 1, 2 ], [ DirectedEdge.new(1, 2) ]))
+
+	    graph = [ DirectedEdge.new(1, 2), DirectedEdge.new(1, 3),
+		DirectedEdge.new(2, 1), DirectedEdge.new(3, 2),
+		DirectedEdge.new(3, 4), DirectedEdge.new(4, 5),
+		DirectedEdge.new(5, 4) ]
+	    assert_equal([[ 4, 5 ], [ 1, 2, 3 ]],
+			 GraphUtils::strongly_connected_components([ 1, 2, 3, 4, 5 ], graph))
+
+	    assert_equal([["y", 2, "z", 3]],
+			 GraphUtils::strongly_connected_components([ "x", "y", "z", 1, 2, 3 ],
+							[ DirectedEdge.new("x", 1), DirectedEdge.new(3, "x"),
+							  DirectedEdge.new("y", 2), DirectedEdge.new(3, "y"),
+							  DirectedEdge.new("z", 3), DirectedEdge.new(2, "z") ]))
+	end
+
+	def testFindPaths
+	    graph = [ DirectedEdge.new(1, 2), DirectedEdge.new(2, 3),
+		      DirectedEdge.new(3, 2), DirectedEdge.new(4, 3) ]
+	    assert_equal(graph[0..2].to_set, GraphUtils::find_paths(1, graph).to_set)
+	    assert_equal(graph[1..3].to_set, GraphUtils::find_paths(4, graph).to_set)
+	end
+    end
+end

data/test/OneOfEqualsConstraintTest.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'OneOfEqualsConstraint'
+require 'Variable'
+require 'Domain'
+
+module ConstraintSolver
+    class OneOfEqualsConstraintTest < Test::Unit::TestCase
+	def setup
+	    @x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
+	    @y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
+	    @constraint = OneOfEqualsConstraint.new([ @x, @y ], 2)
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { OneOfEqualsConstraint.new }
+	    assert_raise(ArgumentError) { OneOfEqualsConstraint.new([], 1) }
+	    assert_nothing_raised { OneOfEqualsConstraint.new([ @x, @y ], 2) }
+	    assert_nothing_raised { OneOfEqualsConstraint.new([ @x, @y ], 2, 0) }
+	end
+
+	def testAssigned
+	    assert_equal(false, @constraint.allAssigned?)
+	    @x.value = 1
+	    assert_equal(false, @constraint.allAssigned?)
+	    @y.value = 1
+	    assert_equal(true, @constraint.allAssigned?)
+	    @x.reset
+	    @y.reset
+	end
+
+	def testInclude
+	    assert_equal(true, @constraint.include?(@x))
+	    assert_equal(true, @constraint.include?(@y))
+	    assert_equal(false, @constraint.include?(Variable.new("2", [ 3 ].to_set)))
+	end
+
+	def testHolds
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 1
+	    @y.value = 1
+	    assert_equal(false, @constraint.holds?)
+	    @x.value = 2
+	    @y.value = 2
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 1
+	    @y.value = 2
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 2
+	    @y.value = 1
+	    assert_equal(true, @constraint.holds?)
+	end
+
+	def testEquals
+	    assert_equal(OneOfEqualsConstraint.new([ @x, @y ], 2), @constraint)
+	    assert_not_equal(OneOfEqualsConstraint.new([ Variable.new("z", Domain.new([ 1, 2 ].to_set)), @y ], 2), @constraint)
+	    assert_not_equal(OneOfEqualsConstraint.new([ @x, @y ], 1), @constraint)
+	end
+
+	def testRevise
+	    assert_equal([ [], 0, false ], @constraint.revise)
+	    @y.value = 2
+	    assert_equal([ [], 0, false ], @constraint.revise)
+	    @y.value = 1
+	    assert_equal([ [ @x ], 0, false ], @constraint.revise)
+	    assert_equal([ 2 ].to_set, @x.domain.values)
+	    @y.reset
+	    @x.domain.undoPruning
+	end
+	
+	def testFaulty
+	    x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
+	    constraint = OneOfEqualsConstraint.new([ x, y ], 3)
+	    y.value = 1
+	    assert_equal([ [ x ], 0, true ], constraint.revise)
+	end
+    end
+end

data/test/ProblemTest.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'Problem'
+require 'Variable'
+require 'BinaryConstraint'
+require 'ConstraintList'
+require 'Domain'
+
+module ConstraintSolver
+    class ProblemTest < Test::Unit::TestCase
+	def setup
+	    @var1 = Variable.new("var1", nil, 1)
+	    var2 = Variable.new("var2", nil, 2)
+	    var3 = Variable.new("var3", nil, 3)
+
+	    @c1 = BinaryConstraint.new(@var1, var2, Proc.new {|a, b| a == b })
+	    c2 = BinaryConstraint.new(var2, var3, Proc.new {|a, b| a < b })
+
+	    @problem = Problem.new([ @var1, var2, var3 ], ConstraintList.new([ @c1, c2 ]))
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { Problem.new } 
+	    assert_raise(ArgumentError) { Problem.new(Array.new, Array.new) }
+	    assert_nothing_raised { Problem.new(@var1, @c1) }
+	    assert_nothing_raised { Problem.new([ @var1 ], [ @c1 ]) }
+	    assert_nothing_raised { Problem.new([ @var1 ], [ @c1 ], {}) }
+	    assert_nothing_raised { Problem.new([ @var1 ], [ @c1 ], {}, true) }
+	    assert_nothing_raised { Problem.new([ @var1 ], [ @c1 ], {}, true, 0) }
+	end
+    end
+end

data/test/SolutionTest.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'Solution'
+require 'Variable'
+require 'Domain'
+require 'extensions'
+
+module ConstraintSolver
+    class SolutionTest < Test::Unit::TestCase
+	def setup
+	    @var = Variable.new("test", Domain.new([ 1 ].to_set), nil, 2)
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { Solution.new }
+	    assert_raise(ArgumentError) { Solution.new(@var) }
+	    @var.value = 1
+	    assert_nothing_raised { Solution.new(@var) }
+	    assert_nothing_raised { Solution.new(@var, {}) }
+	    assert_nothing_raised { Solution.new(@var, {}, 0.5) }
+	    @var.reset
+	end
+
+	def testValues
+	    @var.value = 1
+	    solution = Solution.new(@var, { 1 => 2 })
+	    assert_equal(4, solution.merit)
+	    assert_equal(1, solution.variables.size)
+	    assert_equal(1, solution.variables.first.value)
+	end
+    end
+end

data/test/TestSuite.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby
+
+require 'test/unit'
+glob = $0.split(File::Separator)
+glob.pop
+glob << "*Test.rb"
+glob = glob.join(File::Separator)
+Dir[glob].each { |test|
+    require test
+}

data/test/TupleConstraintTest.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'TupleConstraint'
+require 'Variable'
+require 'Domain'
+
+module ConstraintSolver
+    class TupleConstraintTest < Test::Unit::TestCase
+	def setup
+	    @x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
+	    @y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
+	    @tuples = [ [ 1, 1 ], [ 2, 2 ] ]
+	    @constraint = TupleConstraint.new([ @x, @y ], @tuples)
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { TupleConstraint.new }
+	    assert_raise(ArgumentError) { TupleConstraint.new([ @x, @y ], [ [ 1, 2 ], [ 1 ] ]) }
+	    assert_nothing_raised { TupleConstraint.new([ @x, @y ], @tuples) }
+	    assert_nothing_raised { TupleConstraint.new([ @x, @y ], @tuples, false) }
+	    assert_nothing_raised { TupleConstraint.new([ @x, @y ], @tuples, 0) }
+	end
+
+	def testAssigned
+	    assert_equal(false, @constraint.allAssigned?)
+	    @x.value = 1
+	    assert_equal(false, @constraint.allAssigned?)
+	    @y.value = 1
+	    assert_equal(true, @constraint.allAssigned?)
+	    @x.reset
+	    @y.reset
+	end
+
+	def testInclude
+	    assert_equal(true, @constraint.include?(@x))
+	    assert_equal(true, @constraint.include?(@y))
+	    assert_equal(false, @constraint.include?(Variable.new("2", [ 3 ].to_set)))
+	end
+
+	def testHoldsAllowed
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 1
+	    @y.value = 1
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 2
+	    @y.value = 2
+	    assert_equal(true, @constraint.holds?)
+	    @x.value = 1
+	    @y.value = 2
+	    assert_equal(false, @constraint.holds?)
+	    @x.value = 2
+	    @y.value = 1
+	    assert_equal(false, @constraint.holds?)
+	    @y.reset
+	    @x.value = 2
+	    assert_equal(true, @constraint.holds?)
+	    @x.reset
+	    @y.value = 1
+	    assert_equal(true, @constraint.holds?)
+	    @y.reset
+	end
+
+	def testHoldsDisallowed
+	    constraint = TupleConstraint.new([ @x, @y ], @tuples, false)
+	    assert_equal(true, constraint.holds?)
+	    @x.value = 1
+	    @y.value = 1
+	    assert_equal(false, constraint.holds?)
+	    @x.value = 2
+	    @y.value = 2
+	    assert_equal(false, constraint.holds?)
+	    @x.value = 1
+	    @y.value = 2
+	    assert_equal(true, constraint.holds?)
+	    @x.value = 2
+	    @y.value = 1
+	    assert_equal(true, constraint.holds?)
+	    @y.reset
+	    @x.value = 2
+	    assert_equal(true, constraint.holds?)
+	    @x.reset
+	    @y.value = 1
+	    assert_equal(true, constraint.holds?)
+	end
+
+	def testEquals
+	    assert_equal(TupleConstraint.new([ @x, @y ], @tuples), @constraint)
+	    assert_not_equal(TupleConstraint.new([ Variable.new("z", Domain.new([ 1, 2 ].to_set)), @y ], @tuples), @constraint)
+	    assert_not_equal(TupleConstraint.new([ @x, @y ], [ [ 1, 1 ] ]), @constraint)
+	end
+
+	def testReviseAllowed
+	    x = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = TupleConstraint.new([ x, y, z ], [ [ 1, 2, 3 ], [ 3, 2, 1 ], [ 3, 3, 3 ] ])
+	    assert_equal([ [ x, y, z ], 0, false ], constraint.revise)
+	    assert_equal([ 1, 3 ].to_set, x.domain.values)
+	    assert_equal([ 2, 3 ].to_set, y.domain.values)
+	    assert_equal([ 1, 3 ].to_set, z.domain.values)
+	    x.domain.undoPruning
+	    y.domain.undoPruning
+	    z.domain.undoPruning
+
+	    x.value = 1
+	    assert_equal([ [ y, z ], 0, false ], constraint.revise)
+	    assert_equal([ 2 ].to_set, y.domain.values)
+	    assert_equal([ 3 ].to_set, z.domain.values)
+	    x.reset
+	    y.domain.undoPruning
+	    z.domain.undoPruning
+
+	    z.value = 3
+	    assert_equal([ [ x, y ], 0, false ], constraint.revise)
+	    assert_equal([ 1, 3 ].to_set, x.domain.values)
+	    assert_equal([ 2, 3 ].to_set, y.domain.values)
+	    z.reset
+	    x.domain.undoPruning
+	    y.domain.undoPruning
+
+	    x.value = 2
+	    assert_equal([ [ y ], 0, true ], constraint.revise)
+	end
+
+	def testReviseDisallowed
+	    x = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = TupleConstraint.new([ x, y, z ], [ [ 1, 2, 3 ], [ 3, 2, 1 ], [ 3, 3, 3 ] ], false)
+	    assert_equal([ [], 0, false ], constraint.revise)
+	    x.value = 1
+	    assert_equal([ [ y, z ], 0, false ], constraint.revise)
+	    assert_equal([ 1, 3 ].to_set, y.domain.values)
+	    assert_equal([ 1, 2 ].to_set, z.domain.values)
+	    y.domain.undoPruning
+	    z.domain.undoPruning
+	    x.reset
+
+	    z.value = 3
+	    assert_equal([ [ x, y ], 0, false ], constraint.revise)
+	    assert_equal([ 2 ].to_set, x.domain.values)
+	    assert_equal([ 1 ].to_set, y.domain.values)
+	    x.domain.undoPruning
+	    y.domain.undoPruning
+	    z.reset
+	end
+    end
+end

data/test/VariableTest.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'Variable'
+require 'Domain'
+
+module ConstraintSolver
+    class VariableTest < Test::Unit::TestCase
+	def setup
+	    @variable = Variable.new("test", Domain.new([ 3, 4, 5 ].to_set))
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { Variable.new }
+	    assert_raise(ArgumentError) { Variable.new(nil) }
+	    assert_raise(ArgumentError) { Variable.new(3) }
+	    assert_raise(ArgumentError) { Variable.new("name", Domain.new([ 3 ].to_set), 4) }
+	    assert_nothing_raised {
+		var = Variable.new("name", nil, 3)
+		assert_equal([ 3 ].to_set, var.domain.values)
+	    }
+	    assert_nothing_raised { Variable.new("name", Domain.new([ 3 ].to_set)) }
+	    assert_nothing_raised { Variable.new("name", Domain.new([ 3 ].to_set), 3) }
+	end
+
+	def testAssignment
+	    assert_raise(ArgumentError) { @variable.value = 2 }
+	    assert_nothing_raised { @variable.value = nil }
+	    assert_nothing_raised { @variable.value = 3 }
+	    assert(@variable.assigned?)
+	    assert_equal(3, @variable.value)
+	    @variable.reset
+	    assert_equal(false, @variable.assigned?)
+	    assert_equal(nil, @variable.value)
+	end
+
+	def testEquals
+	    assert_equal(@variable, Variable.new("test", Domain.new([ 3, 4, 5 ].to_set)))
+	    assert_equal(@variable, Variable.new("test", Domain.new(Set.new)))
+	    assert_not_equal(@variable, Variable.new("test", nil, 3))
+	    assert_not_equal(@variable, Variable.new("test", Domain.new([ 3, 4, 5 ].to_set), 3))
+	    assert_not_equal(@variable, Variable.new("tester", Domain.new([ 3, 4, 5 ].to_set)))
+	end
+    end
+end