ConstraintSolver 0.1

data/test/BinaryConstraintTest.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'BinaryConstraint'
+require 'Variable'
+require 'Domain'
+
+module ConstraintSolver
+    class BinaryConstraintTest < Test::Unit::TestCase
+	def setup
+	    @lhs = Variable.new("lhs", Domain.new([ 1, 2 ].to_set))
+	    @rhs = Variable.new("rhs", Domain.new([ 1, 2 ].to_set))
+	    @rel = BinaryRelation.new("==")
+	    @constraint = BinaryConstraint.new(@lhs, @rhs, @rel)
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { BinaryConstraint.new }
+	    assert_raise(ArgumentError) { BinaryConstraint.new(@lhs, @rhs, Proc.new { |a| a }) }
+	    assert_nothing_raised { BinaryConstraint.new(@lhs, @rhs, @rel) }
+	    assert_nothing_raised { BinaryConstraint.new(@lhs, @rhs, @rel, 0) }
+	end
+
+	def testAssigned
+	    assert_equal(false, @constraint.allAssigned?)
+	    @rhs.value = 1
+	    assert_equal(false, @constraint.allAssigned?)
+	    @lhs.value = 1
+	    assert_equal(true, @constraint.allAssigned?)
+	    @rhs.reset
+	    @lhs.reset
+	end
+
+	def testInclude
+	    assert_equal(true, @constraint.include?(@lhs))
+	    assert_equal(true, @constraint.include?(@rhs))
+	    assert_equal(false, @constraint.include?(Variable.new("2", [ 3 ].to_set)))
+	end
+
+	def testHolds
+	    assert_equal(true, @constraint.holds?)
+	    assert_nothing_raised { @lhs.value = 1 }
+	    assert_nothing_raised { @rhs.value = 2 }
+	    assert_equal(false, @constraint.holds?)
+	    assert_nothing_raised { @rhs.value = 1 }
+	    assert_equal(true, @constraint.holds?)
+	    @lhs.reset
+	    @rhs.reset
+	end
+
+	def testEquals
+	    assert_equal(BinaryConstraint.new(@lhs, @rhs, @rel), @constraint)
+	    assert_not_equal(BinaryConstraint.new(@lhs, @rhs, BinaryRelation.new("<")), @constraint)
+	    assert_not_equal(BinaryConstraint.new(Variable.new("foo", [ 1 ].to_set), @rhs, @rel), @constraint)
+	    assert_not_equal(BinaryConstraint.new(@lhs, Variable.new("foo", [ 1 ].to_set), @rel), @constraint)
+	end
+
+	def testRevise
+	    lhs = Variable.new("x", Domain.new([ 1 ].to_set))
+	    rhs = Variable.new("y", Domain.new([ 1, 2, 3, 4 ].to_set))
+	    rel = BinaryRelation.new("<")
+	    constraint = BinaryConstraint.new(lhs, rhs, rel)
+	    revisedVariables, checks, wipeout = constraint.revise
+	    assert_equal(false, wipeout)
+	    assert_equal([ rhs ], revisedVariables)
+	    assert_equal(4, checks)
+	    assert_equal([ 2, 3, 4 ].to_set, rhs.values)
+
+	    lhs = Variable.new("x", Domain.new([ 1 ].to_set), 1)
+	    rhs = Variable.new("y", Domain.new([ 1, 2, 3, 4 ].to_set))
+	    rel = BinaryRelation.new("<")
+	    constraint = BinaryConstraint.new(lhs, rhs, rel)
+	    revisedVariables, checks, wipeout = constraint.revise
+	    assert_equal(false, wipeout)
+	    assert_equal([ rhs ], revisedVariables)
+	    assert_equal(4, checks)
+	    assert_equal([ 2, 3, 4 ].to_set, rhs.values)
+
+	    lhs = Variable.new("x", Domain.new([ 1 ].to_set), 1)
+	    rhs = Variable.new("y", Domain.new([ 1, 2, 3, 4 ].to_set), 4)
+	    rel = BinaryRelation.new("<")
+	    constraint = BinaryConstraint.new(lhs, rhs, rel)
+	    revisedVariables, checks, wipeout = constraint.revise
+	    assert_equal(false, wipeout)
+	    assert_equal([], revisedVariables)
+	    assert_equal(0, checks)
+	end
+
+	def testReviseNothing
+	    lhs = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set))
+	    rhs = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
+	    rel = BinaryRelation.new("!=")
+	    constraint = BinaryConstraint.new(lhs, rhs, rel)
+	    revisedVariables, checks = constraint.revise
+	    assert_equal([ ], revisedVariables)
+	    assert_equal(9, checks)
+	end
+    end
+
+    class BinaryRelationTest < Test::Unit::TestCase
+	def testConstructor
+	    assert_raise(ArgumentError) { BinaryRelation.new }
+	    assert_nothing_raised { BinaryRelation.new("<") }
+	end
+    end
+end

data/test/ConstraintListTest.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'ConstraintList'
+require 'BinaryConstraint'
+require 'Variable'
+require 'Domain'
+require 'AllDifferentConstraint'
+
+module ConstraintSolver
+    class ConstraintListTest < Test::Unit::TestCase
+	def setup
+	    @var1 = Variable.new("test1", Domain.new([ 1 ].to_set), 1)
+	    @var2 = Variable.new("test2", Domain.new([ 1 ].to_set), 1)
+	    @var3 = Variable.new("test3", Domain.new([ 1 ].to_set))
+
+	    @proc = Proc.new {|a, b| a == b }
+
+	    @con1 = BinaryConstraint.new(@var1, @var2, @proc)
+	    @con2 = BinaryConstraint.new(@var1, @var3, @proc)
+
+	    @cl = ConstraintList.new([ @con1, @con2 ])
+	end
+
+	def testNotAllAssignedWithVariable
+	    assert_equal(ConstraintList.new([ @con2 ]), @cl.notAllAssignedWithVariable(@var1))
+	end
+
+	def testAllWithVariable
+	    assert_equal(ConstraintList.new([ @con1, @con2 ]), @cl.allWithVariable(@var1))
+	end
+
+	def testAllDifferentConstraintList
+	    allDiff = AllDifferentConstraint.new([ @var1, @var2, @var3 ])
+	    list = ConstraintList.new([ allDiff ])
+	    assert_equal(list, list.notAllAssignedWithVariable(@var1))
+	end
+    end
+end

data/test/ConstraintSolverTest.rb

@@ -0,0 +1,274 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'log4r'
+require 'ConstraintSolver'
+
+include Log4r
+
+module ConstraintSolver
+    class ConstraintSolverTest < Test::Unit::TestCase
+	def setup
+	    @var1 = Variable.new("x", Domain.new([ 1, 2 ].to_set), nil, 1)
+	    @var2 = Variable.new("y", Domain.new([ 1, 2 ].to_set), nil, 2)
+	    @var3 = Variable.new("z", Domain.new([ 1, 2 ].to_set), nil, 3)
+	    relation = BinaryRelation.new("!=")
+	    constraint1 = BinaryConstraint.new(@var1, @var2, relation)
+	    constraint2 = BinaryConstraint.new(@var1, @var3, relation.clone)
+	    constraint3 = BinaryConstraint.new(@var2, @var3, relation.clone)
+	    @meritMap = { 1 => 2, 2 => 1 }
+	    @solvableProblem = Problem.new([ @var1, @var2 ], ConstraintList.new([ constraint1 ]), @meritMap)
+	    @unsolvableProblem = Problem.new([ @var1, @var2, @var3 ],
+					     ConstraintList.new([ constraint1, constraint2, constraint3 ]))
+	    @solver = ConstraintSolver.new
+	end
+
+	def testConstructor
+	    assert_nothing_raised { ConstraintSolver.new }
+	end
+
+	def testSolvableProblem
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(@solvableProblem)
+	    assert_equal(false, solutions.empty?)
+	    assert_equal(2, solutions.size)
+	    @var1.value = 2
+	    @var2.value = 1
+	    assert_equal(Solution.new([ @var1, @var2 ], @meritMap), solutions[0])
+	    assert_equal(5, solutions[0].merit)
+	    @var1.value = 1
+	    @var2.value = 2
+	    assert_equal(Solution.new([ @var1, @var2 ], @meritMap), solutions[1])
+	    assert_equal(4, solutions[1].merit)
+	    @var1.reset
+	    @var2.reset
+	    assert_equal(4, nodeChecks)
+	    assert_equal(4, constraintChecks)
+	end
+
+	def testUnsolvableProblem
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(@unsolvableProblem)
+	    assert_equal(true, solutions.empty?)
+	    assert_equal(2, nodeChecks)
+	    assert_equal(10, constraintChecks)
+	end
+
+	def testAllDifferentProblem
+	    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 = AllDifferentConstraint.new([ x, y, z ])
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(Problem.new([ x, y, z ], constraint))
+	    assert_equal(6, solutions.size)
+	    assert_equal(15, nodeChecks)
+	    #assert_equal(27, constraintChecks)
+	end
+
+	def testAllDifferentWithoutAllDifferent
+	    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))
+	    relation = BinaryRelation.new("!=")
+	    c1 = BinaryConstraint.new(x, y, relation)
+	    c2 = BinaryConstraint.new(x, z, relation.clone)
+	    c3 = BinaryConstraint.new(y, z, relation.clone)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks =
+		@solver.solve(Problem.new([ x, y, z ], ConstraintList.new([ c1, c2, c3 ]))) 
+	    assert_equal(6, solutions.size)
+	    assert_equal(15, nodeChecks)
+	    assert_equal(48, constraintChecks)
+	end
+
+	def testVariableAndValueOrdering
+	    meritMap = { "foo" => 1, "bar" => 2, "foobar" => 3 }
+	    x = Variable.new("x", Domain.new([ "foo", "bar", "foobar" ].to_set), nil, 1)
+	    y = Variable.new("y", Domain.new([ "foo", "bar", "foobar" ].to_set), nil, 2)
+	    c = AllDifferentConstraint.new([ x, y ])
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions = @solver.solve(Problem.new([ x, y ], c, meritMap))[0]
+	    assert_equal(6, solutions.size)
+	    assert_equal(8, solutions[0].merit)
+	    assert_equal(7, solutions[1].merit)
+	    assert_equal(7, solutions[2].merit)
+	    assert_equal(5, solutions[3].merit)
+	    assert_equal(5, solutions[4].merit)
+	    assert_equal(4, solutions[5].merit)
+	end
+
+	def testPreemptiveSolving
+	    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 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    #@solver.log.outputters = Outputter.stderr
+	    allSolutions = @solver.solve(Problem.new([ x, y, z ], constraint))[0]
+	    assert_equal(4, allSolutions.size)
+	    firstSolution = @solver.solve(Problem.new([ x, y, z ], constraint, {}, true))[0]
+	    assert_equal(1, firstSolution.size)
+	    assert_equal(allSolutions[0], firstSolution[0])
+	end
+
+	def testPartialAssignment
+	    x = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set), 1)
+	    y = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions = @solver.solve(Problem.new([ x, y, z ], constraint))[0]
+	    assert_equal(2, solutions.size)
+	end
+
+	def testSeveralAllDiff
+	    a = Variable.new("11", Domain.new([ 1, 2 ].to_set))
+	    b = Variable.new("12", Domain.new([ 1, 2 ].to_set), 2)
+	    c = Variable.new("21", Domain.new([ 1, 2 ].to_set))
+	    d = Variable.new("22", Domain.new([ 1, 2 ].to_set), 2)
+	    constraints = ConstraintList.new
+	    constraints << AllDifferentConstraint.new([ a, b ])
+	    constraints << AllDifferentConstraint.new([ c, d ])
+	    constraints << AllDifferentConstraint.new([ a, c ])
+	    constraints << AllDifferentConstraint.new([ b, d ])
+	    solutions = @solver.solve(Problem.new([ a, b, c, d ], constraints))[0]
+	    assert_equal(0, solutions.size)
+	end
+
+	def testSoftConstraints
+	    x = Variable.new("x", Domain.new([ 1 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1 ].to_set))
+	    constraints = ConstraintList.new
+	    constraints << BinaryConstraint.new(x, y, BinaryRelation.new("!="), 0.5)
+	    problem = Problem.new([ x, y ], constraints, {}, false, 1)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(problem)
+	    assert_equal(1, solutions.size)
+	    assert_equal(1, solutions[0].variables[0].value)
+	    assert_equal(1, solutions[0].variables[1].value)
+	    assert_equal(0.5, solutions[0].violation)
+	    assert_equal(4, nodeChecks)
+	    assert_equal(1, constraintChecks)
+
+	    x.value = 1
+	    y.value = 1
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(problem)
+	    assert_equal(1, solutions.size)
+	    assert_equal(1, solutions[0].variables[0].value)
+	    assert_equal(1, solutions[0].variables[1].value)
+	    assert_equal(0.5, solutions[0].violation)
+	    assert_equal(2, nodeChecks)
+	    assert_equal(1, constraintChecks)
+	end
+
+	def testComplexSoftConstraints
+	    a = Variable.new("a", Domain.new([ 1, 2, 3 ].to_set))
+	    b = Variable.new("b", Domain.new([ 1, 2, 3 ].to_set))
+	    c = Variable.new("c", Domain.new([ 1, 2, 3 ].to_set))
+	    d = Variable.new("d", Domain.new([ 1, 2, 3 ].to_set))
+	    constraints = ConstraintList.new
+	    constraints << AllDifferentConstraint.new([ a, b, c, d ], 0.1)
+	    rel = BinaryRelation.new("<")
+	    constraints << BinaryConstraint.new(a, b, rel, 0.5)
+	    constraints << BinaryConstraint.new(b, c, rel, 0.5)
+	    constraints << BinaryConstraint.new(c, d, rel, 0.5)
+	    problem = Problem.new([ a, b, c, d ], constraints, {}, false, 1)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(problem)
+	    assert_equal(15, solutions.size)
+	    assert_equal(90, nodeChecks)
+	    assert_equal(220, constraintChecks)
+	    solutions.each { |solution|
+		assert_equal(0.6, solution.violation)
+	    }
+	end
+
+	def testTimeLimitHardConstraints
+	    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))
+	    relation = BinaryRelation.new("!=")
+	    c1 = BinaryConstraint.new(x, y, relation)
+	    c2 = BinaryConstraint.new(x, z, relation.clone)
+	    c3 = BinaryConstraint.new(y, z, relation.clone)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks =
+		@solver.solve(Problem.new([ x, y, z ], ConstraintList.new([ c1, c2, c3 ])), 0.000001) 
+	    assert_equal(1, solutions.size)
+	    assert_equal(-3, solutions[0].merit)
+	    assert_equal(3, solutions[0].violation)
+	end
+
+	def testTimeLimitSoftConstraints
+	    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))
+	    relation = BinaryRelation.new("!=")
+	    c1 = BinaryConstraint.new(x, y, relation, 0.2)
+	    c2 = BinaryConstraint.new(x, z, relation.clone, 0.5)
+	    c3 = BinaryConstraint.new(y, z, relation.clone, 1)
+	    #@solver.log.outputters = Outputter.stderr
+	    # Depending on the time limit and the particular machine,
+	    # constraints will be discarded. Change the value and enable logging
+	    # to see for yourself.
+	    timeLimit = 0.0014
+	    solutions, nodeChecks, constraintChecks =
+		@solver.solve(Problem.new([ x, y, z ], ConstraintList.new([ c1, c2, c3 ]), {}, true, 1), timeLimit) 
+	    assert_equal(1, solutions.size)
+	end
+
+	def testTimeLimitSoftAllDiff
+	    x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y ], 1)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(Problem.new([ x, y ], constraint,
+										{ 1 => 1, 2 => 2 }, false, 0), 10)
+	    assert_equal(2, solutions.size)
+	    assert_equal(4, nodeChecks)
+	end
+
+	def testTupleConstraint
+	    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 ] ])
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(Problem.new([ x, y, z ], constraint))
+	    assert_equal(2, solutions.size)
+	    assert_equal(7, nodeChecks)
+	    assert_equal(0, constraintChecks)
+
+	    assert_equal(1, solutions[0].variables[0].value)
+	    assert_equal(2, solutions[0].variables[1].value)
+	    assert_equal(3, solutions[0].variables[2].value)
+
+	    assert_equal(3, solutions[1].variables[0].value)
+	    assert_equal(2, solutions[1].variables[1].value)
+	    assert_equal(1, solutions[1].variables[2].value)
+	end
+
+	def testOneOfEqualsConstraint
+	    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)
+	    #@solver.log.outputters = Outputter.stderr
+	    solutions, nodeChecks, constraintChecks = @solver.solve(Problem.new([ x, y ], constraint))
+	    assert_equal(3, solutions.size)
+	    assert_equal(5, nodeChecks)
+	    assert_equal(0, constraintChecks)
+
+	    assert_equal(1, solutions[0].variables[0].value)
+	    assert_equal(2, solutions[0].variables[1].value)
+
+	    assert_equal(2, solutions[1].variables[0].value)
+	    assert_equal(1, solutions[1].variables[1].value)
+
+	    assert_equal(2, solutions[2].variables[0].value)
+	    assert_equal(2, solutions[2].variables[1].value)
+	end
+    end
+end

data/test/DomainTest.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'Domain'
+
+module ConstraintSolver
+    class DomainTest < Test::Unit::TestCase
+	def setup
+	    @domain = Domain.new([ 2, 3, 4 ].to_set)
+	end
+
+	def testConstructor
+	    assert_nothing_raised { Domain.new }
+	    assert_raise(ArgumentError) { Domain.new(3) }
+	    assert_raise(ArgumentError) { Domain.new([ 2 ]) }
+	    assert_nothing_raised { Domain.new([ 2 ].to_set) }
+	    assert_nothing_raised { Domain.new([ 2, 3, 4 ].to_set) }
+	end
+
+	def testDomainAddDelete
+	    domain = Domain.new
+	    assert(domain.empty?)
+	    domain << 3
+	    assert(domain.include?(3))
+	    domain.delete(3)
+	    assert(domain.empty?)
+	end
+
+	def testPruneSet
+	    @domain.prune([ 2 ].to_set)
+	    assert_equal([ 3, 4 ].to_set, @domain.values)
+	    @domain.prune([ 3 ].to_set)
+	    assert_equal([ 4 ].to_set, @domain.values)
+	    @domain.undoPruning
+	    assert_equal([ 3, 4 ].to_set, @domain.values)
+	    @domain.undoPruning
+	    assert_equal([ 2, 3, 4 ].to_set, @domain.values)
+
+	    @domain.prune([ 2, 3 ].to_set)
+	    assert_equal([ 4 ].to_set, @domain.values)
+	    begin
+		@domain.prune([ 4 ].to_set)
+	    rescue DomainWipeoutException
+		assert_equal([].to_set, @domain.values)
+	    end
+	    @domain.undoPruning
+	    assert_equal([ 4 ].to_set, @domain.values)
+	    @domain.undoPruning
+	    assert_equal([ 2, 3, 4 ].to_set, @domain.values)
+	end
+
+	def testPruneScalar
+	    @domain.prune(2)
+	    assert_equal([ 3, 4 ].to_set, @domain.values)
+	    @domain.undoPruning
+	    assert_equal([ 2, 3, 4 ].to_set, @domain.values)
+	end
+
+	def testPruneWithErrors
+	    assert_raise(UndoStackEmptyException) { @domain.undoPruning }
+	    assert_raise(DomainWipeoutException) { @domain.prune([ 2, 3, 4 ].to_set) }
+	end
+
+	def testPruneWipeout
+	    begin
+		@domain.prune([ 2, 3, 4 ].to_set)
+	    rescue DomainWipeoutException
+		assert_equal(Set.new, @domain.values)
+		return
+	    end
+	    fail
+	end
+
+	def testEquals
+	    assert_equal(@domain, Domain.new([ 2, 3, 4 ].to_set))
+	    assert_not_equal(@domain, Domain.new([ 2, 3 ].to_set))
+	    @domain.prune(4)
+	    assert_not_equal(@domain, Domain.new([ 2, 3 ].to_set))
+	end
+    end
+end