ConstraintSolver 0.1

data/lib/OneOfEqualsConstraint.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby
+
+require 'AbstractConstraint'
+require 'extensions'
+
+module ConstraintSolver
+    # Represents a one-of-equals constraint.
+    class OneOfEqualsConstraint < AbstractConstraint
+	attr_reader :variables, :value, :violationCost
+	# Initialises a new one-of-equals constraint.
+	# The arguments are the list of variables involved in the constraint and
+	# the value at least one of the variables should be equal to.
+	# Optionally, a cost for violating the constraint can be specified.
+	def initialize(variables, value, violationCost=1)
+	    if variables.empty?
+		raise ArgumentError, "List of variables must not be empty!"
+	    end
+	    @variables = variables
+	    @value = value
+	    @violationCost = violationCost
+	end
+
+	def holds?
+	    if not allAssigned? or not @variables.find { |var| var.value == @value }.nil?
+		return true
+	    else
+		return false
+	    end
+	end
+
+	def allAssigned?
+	    @variables.each { |var|
+		return false if not var.assigned?
+	    }
+	    return true
+	end
+
+	def include?(variable)
+	    @variables.include?(variable)
+	end
+
+	def to_s
+	    @variables.collect { |var| var.name }.join(" != ")
+	end
+
+	def to_s_full
+	    @variables.collect { |var| var.to_s }.join(" != ")
+	end
+
+	def ==(constraint)
+	    return false unless constraint.kind_of?(OneOfEqualsConstraint)
+	    (@variables == constraint.variables) and (@value == constraint.value) and
+		(@violationCost == constraint.violationCost)
+	end
+
+	def each
+	    @variables.each { |var|
+		yield var
+	    }
+	end
+
+	def revise
+	    checks = 0
+	    revisedVariables = []
+	    wipeout = false
+	    if @variables.find_all { |var| var.assigned? and not var.value == @value }.size == @variables.size - 1
+		unassigned = @variables.find { |var| not var.assigned? }
+		pruneList = unassigned.domain.values - [ @value ]
+		if not pruneList.empty?
+		    begin
+			unassigned.domain.prune(pruneList)
+		    rescue DomainWipeoutException
+			wipeout = true
+		    end
+		    revisedVariables << unassigned
+		end
+	    end
+	    return revisedVariables, checks, wipeout
+	end
+    end
+end

data/lib/Problem.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+module ConstraintSolver
+    # Representation of a constraint satisfaction problem.
+    class Problem
+	attr_reader :variables, :constraints, :meritMap, :firstSolution, :maxViolation
+	# Creates a new instances of a constraint satisfaction problem.
+	# The constructor takes the lists of variables and constraints as parameters.
+	# Optionally, a map that maps domain elements to their merit,
+	# a boolean indicating whether to sop solving after a solution has
+	# been found, and a number designating the maximum cost for constraint
+	# violation that can be accepted can be specified.
+	def initialize(variables, constraints, meritMap={}, firstSolution=false, maxViolation=0)
+	    if not variables.kind_of?(Array)
+		variables = [ variables ]
+	    end
+	    if not constraints.kind_of?(ConstraintList)
+		constraints = ConstraintList.new([ constraints ])
+	    end
+	    if variables.empty? or constraints.empty?
+		raise ArgumentError, "Variables and constraints must not be empty!"
+	    end
+	    @variables = variables
+	    @constraints = constraints
+	    @meritMap = meritMap
+	    @firstSolution = firstSolution
+	    @maxViolation = maxViolation
+	end
+    end
+end

data/lib/Solution.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+
+module ConstraintSolver
+    # This class represents a solution to a constraint satisfaction problem.
+    class Solution
+	attr_reader :variables, :merit, :violation
+	# Initialises a new solution with a list of variables. The variables
+	# must all have values assigned to them.
+	# Optionally, a map to map domain values of variables to their merit and
+	# a number designating the cost of violating constraints in the solution can
+	# be specified.
+	def initialize(variables, meritMap={}, violation=0)
+	    if not variables.kind_of?(Array)
+		variables = Array.new([ variables ])
+	    end
+	    if variables.inject(true) { |res,var| res & var.assigned? }
+		@variables = Array.new
+		variables.each { |variable|
+		    @variables << variable.dup
+		}
+	    else
+		raise ArgumentError, "All variables must have values assigned to them!"
+	    end
+	    @merit = 0
+	    @variables.each { |var|
+		@merit += meritMap[var.value] ? var.merit * meritMap[var.value] : var.merit
+	    }
+	    @violation = violation
+	    @merit -= @violation
+	end
+
+	def each
+	    @variables.each { |variable|
+		yield variable
+	    }
+	end
+
+	def <=>(solution)
+	    @value <=> solution.value
+	end
+
+	def ==(solution)
+	    return false unless solution.kind_of?(Solution)
+	    @variables == solution.variables and @merit == solution.merit and @violation == solution.violation
+	end
+
+	def to_s
+	    s = (@variables.collect { |variable|
+		variable.to_s
+	    }).join(", ")
+	    s += ", merit " + @merit.to_s unless @merit.nil?
+	    s += ", violation " + @violation.to_s unless @violation.nil?
+	    return s
+	end
+    end
+end

data/lib/TupleConstraint.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/ruby
+
+require 'AbstractConstraint'
+require 'extensions'
+
+module ConstraintSolver
+    # Represents a constraint which is specified by the allowed or disallowed
+    # tuples of arbitrary arity.
+    class TupleConstraint < AbstractConstraint
+	attr_reader :variables, :tuples, :allowedTuples, :violationCost
+	# Initialises a new tuple constraint.
+	# The first argument is the list of variables involved in the
+	# constraint, the second argument is an array of tuples. Each element of
+	# the array is an array with exactly as many elements as the array of
+	# variables. The third argument specifies whether the array of tuples
+	# lists the allowed or disallowed tuples. Default is allowed tuples.
+	# Optionally, a cost for violating the constraint can be specified.
+	def initialize(variables, tuples, allowedTuples=true, violationCost=1)
+	    @variables = variables
+	    unless tuples.inject(true) { |bool,tuple| bool & (tuple.size == variables.size) }
+		raise ArgumentError, "All tuples must have " + variables.size.to_s + " elements!"
+	    end
+	    @tuples = tuples
+	    @violationCost = violationCost
+	    @allowedTuples = allowedTuples
+	end
+
+	# Checks whether the assignments to the variables are allowed tuples.
+	def holds?
+	    tups = @tuples
+	    @variables.each_with_index { |var,i|
+		next unless var.assigned?
+		tups = tups.find_all { |tup| tup[i] == var.value }
+		if @allowedTuples
+		    return false if tups.empty?
+		end
+	    }
+	    if not @allowedTuples and allAssigned? and tuples.include?(@variables.collect { |var| var.value })
+		return false
+	    end
+	    return true
+	end
+
+	def allAssigned?
+	    @variables.each { |var|
+		return false if not var.assigned?
+	    }
+	    return true
+	end
+
+	def include?(variable)
+	    @variables.include?(variable)
+	end
+
+	def to_s
+	    @variables.collect { |var| var.name }.join(", ") + ": " + tuples.join(", ")
+	end
+
+	def to_s_full
+	    @variables.collect { |var| var.to_s }.join(", ") + ": " + tuples.join(", ")
+	end
+
+	def ==(constraint)
+	    return false unless constraint.kind_of?(TupleConstraint)
+	    (@variables == constraint.variables) and (@tuples == constraint.tuples) and
+		(@allowedTuples == constraint.allowedTuples) and (@violationCost == constraint.violationCost)
+	end
+
+	def each
+	    @variables.each { |var|
+		yield var
+	    }
+	end
+
+	def revise
+	    revisedVariables = []
+	    checks = 0
+	    wipeout = false
+	    assignedIndices, unassignedIndices = (0..(@variables.size - 1)).partition { |i| @variables[i].assigned? }
+	    pruneTuples = (@allowedTuples ? @tuples : [])
+	    assignedIndices.each { |i|
+		if @allowedTuples
+		    pruneTuples = pruneTuples.find_all { |tup| tup[i] == @variables[i].value }
+		else
+		    (@tuples - pruneTuples).each { |tup|
+			if @variables[i].value == tup[i]
+			    pruneTuples << tup
+			end
+		    }
+		end
+	    }
+	    unassignedIndices.each { |i|
+		var = @variables[i]
+		pruneList = pruneTuples.collect { |tup| tup[i] }.to_set
+		if @allowedTuples
+		    pruneList = var.domain.values - pruneList
+		end
+		if var.domain.include_any?(pruneList)
+		    begin
+			var.domain.prune(pruneList)
+		    rescue DomainWipeoutException
+			wipeout = true
+		    end
+		    revisedVariables << var
+		    break if wipeout
+		end
+	    }
+	    return revisedVariables, checks, wipeout
+	end
+    end
+end

data/lib/Variable.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/ruby
+
+module ConstraintSolver
+    # This class represents a variable in a constraint satisfaction problem.
+    class Variable
+	attr_reader :name, :domain, :value, :merit
+	# Initialises a new variable. The name of the variable and at least one
+	# of domain or value are required.
+	# If domain is nil and a value is given, a new Domain is constructed
+	# with only the value specified in it.
+	# The fourth argument is the merit of the variable.
+	def initialize(name, domain=nil, value=nil, merit=0)
+	    if not name.kind_of?(String)
+		raise ArgumentError, "The name of the variable has to be specified."
+	    end
+	    if domain.nil? and value.nil?
+		raise ArgumentError, "At least one of domain or value are required."
+	    end
+	    @name = name
+	    @value = value
+	    if not domain.nil? and not domain.kind_of?(Domain)
+		domain = Domain.new([ domain ].to_set);
+	    end
+	    if value.nil?
+		@domain = domain.nil? ? Domain.new : domain
+	    else
+		if domain.nil?
+		    @domain = Domain.new([ value ].to_set)
+		else
+		    if domain.include?(value)
+			@domain = domain
+		    else
+			raise ArgumentError, "Value " + value.to_s + " not in domain " + domain.to_s + "!"
+		    end
+		end
+	    end
+	    @merit = merit
+	end
+
+	# Assigns a new value to the variable.
+	# The new value has to be in the domain of the variable.
+	def value=(value)
+	    if value.nil?
+		return
+	    end
+	    if @domain.include?(value)
+		@value = value
+	    else
+		raise ArgumentError, "The domain of " + @name.to_s + " (" + @domain.to_s +
+		    ") does not contain " + value.to_s + "!"
+	    end
+	end
+
+	def values
+	    domain.values
+	end
+
+	def to_s
+	    @name.to_s + " = " + @value.to_s + " \\in " + @domain.to_s
+	end
+
+	def ==(variable)
+	    variable.kind_of?(Variable) and (@name == variable.name) and (@value == variable.value)
+	end
+
+	def assigned?
+	    not @value.nil?
+	end
+
+	def reset
+	    @value = nil
+	end
+    end
+end

data/lib/extensions.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+
+class Array
+    def rest
+	retval = self.clone
+	retval.shift
+	return retval
+    end
+
+    def foldLeft(function)
+	if self.size == 1
+	    return self.first
+	else
+	    return function.call(self.first, self.rest.foldLeft(function))
+	end
+    end
+
+    def eachAfter(element, &block)
+	self[((self.index(element) or -1) + 1)..-1].each { |x|
+	    yield x
+	}
+    end
+
+    def eachStartWith(element, &block)
+	self[(self.index(element) or 0)..-1].each { |x|
+	    yield x
+	}
+    end
+end
+
+class Fixnum
+    def not_equal?(num)
+	self != num
+    end
+end
+
+class Set
+    def include_any?(enum)
+	enum.each { |e|
+	    if self.include?(e)
+		return true
+	    end
+	}
+	return false
+    end
+end
+
+class Hash
+    def include_hash?(hash)
+	hash.each { |k,v|
+	    return false unless self[k] == v
+	}
+	return true
+    end
+end

data/test/AllDifferentConstraintTest.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'AllDifferentConstraint'
+require 'Variable'
+require 'Domain'
+
+module ConstraintSolver
+    class AllDifferentConstraintTest < Test::Unit::TestCase
+	def setup
+	    @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 ])
+	end
+
+	def testConstructor
+	    assert_raise(ArgumentError) { AllDifferentConstraint.new }
+	    assert_raise(ArgumentError) { AllDifferentConstraint.new([]) }
+	    assert_raise(ArgumentError) { AllDifferentConstraint.new([ @x ]) }
+	    assert_nothing_raised { AllDifferentConstraint.new([ @x, @y, @z ]) }
+	    assert_nothing_raised { AllDifferentConstraint.new([ @x, @y, @z ], 0) }
+	end
+
+	def testAssigned
+	    assert_equal(false, @constraint.allAssigned?)
+	    @y.value = 1
+	    @z.value = 1
+	    assert_equal(false, @constraint.allAssigned?)
+	    @x.value = 1
+	    assert_equal(true, @constraint.allAssigned?)
+	    @x.reset
+	    @y.reset
+	    @z.reset
+	end
+
+	def testInclude
+	    assert_equal(true, @constraint.include?(@x))
+	    assert_equal(true, @constraint.include?(@y))
+	    assert_equal(true, @constraint.include?(@z))
+	    assert_equal(false, @constraint.include?(Variable.new("foobar", 1)))
+	end
+
+	def testEquals
+	    assert_not_equal(AllDifferentConstraint.new([ @x, @y ]), @constraint)
+	    assert_equal(AllDifferentConstraint.new([ @x, @y, @z ]), @constraint)
+	end
+
+	def testHolds
+	    @x.value = 1
+	    @y.value = 2
+	    @z.value = 2
+	    assert_equal(false, @constraint.holds?)
+	    @z.value = 3
+	    assert_equal(true, @constraint.holds?)
+	    @constraint.variables.each { |var| var.reset }
+	end
+
+	def testRevise_decomposed_local
+	    assert_equal([ [], 0, false ], @constraint.revise_decomposed_local)
+	    @x.value = 1
+	    assert_equal([ [ @y, @z ], 0, false ], @constraint.revise_decomposed_local)
+	    assert_equal([ 2, 3 ].to_set, @y.values)
+	    assert_equal([ 2, 3 ].to_set, @z.values)
+	    @x.reset
+
+	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
+	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    assert_equal([ [], 0, false ], constraint.revise_decomposed_local)
+	    assert_equal([ 1, 3 ].to_set, x.values)
+	    assert_equal([ 2, 3 ].to_set, y.values)
+	    assert_equal([ 2, 3 ].to_set, z.values)
+
+	    a = Variable.new("a", Domain.new([ 1 ].to_set))
+	    b = Variable.new("b", Domain.new([ 1, 2 ].to_set))
+	    c = Variable.new("c", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ a, b, c ])
+	    assert_equal([ [ b, c, c ], 0, false ], constraint.revise_decomposed_local)
+	    assert_equal([ 1 ].to_set, a.values)
+	    assert_equal([ 2 ].to_set, b.values)
+	    assert_equal([ 3 ].to_set, c.values)
+	end
+
+	def testDomainWipeout_decomposed_local
+	    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))
+	    a = Variable.new("a", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z, a ])
+	    a.value = 1
+	    assert_equal([ [ x, y, z ], 0, true ], constraint.revise_decomposed_local)
+	end
+
+	def testRevise_hyperarc
+	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
+	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    assert_equal([ [ x ], 0, false ], constraint.revise_hyperarc)
+	    assert_equal([ 1 ].to_set, x.values)
+	    assert_equal([ 2, 3 ].to_set, y.values)
+	    assert_equal([ 2, 3 ].to_set, z.values)
+
+	    a = Variable.new("a", Domain.new([ 1 ].to_set))
+	    b = Variable.new("b", Domain.new([ 1, 2 ].to_set))
+	    c = Variable.new("c", Domain.new([ 1, 2, 3 ].to_set))
+	    constraint = AllDifferentConstraint.new([ a, b, c ])
+	    revisedVariables, checks, wipeout = constraint.revise_hyperarc
+	    assert_equal(false, wipeout)
+	    assert_equal(Set.new, [ b, c ].to_set - revisedVariables.to_set)
+	    assert_equal(0, checks)
+	    assert_equal([ 1 ].to_set, a.values)
+	    assert_equal([ 2 ].to_set, b.values)
+	    assert_equal([ 3 ].to_set, c.values)
+	    
+	    assert_equal([ [], 0, false ], constraint.revise_hyperarc)
+
+	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
+	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
+	    z = Variable.new("z", Domain.new([ 2, 3, 4 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    assert_equal([ [], 0, false ], constraint.revise_hyperarc)
+	    assert_equal([ 1, 3 ].to_set, x.values)
+	    assert_equal([ 2, 3 ].to_set, y.values)
+	    assert_equal([ 2, 3, 4 ].to_set, z.values)
+	end
+
+	def testDomainWipeout_hyperarc
+	    x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
+	    y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
+	    z = Variable.new("z", Domain.new([ 1, 2 ].to_set))
+	    constraint = AllDifferentConstraint.new([ x, y, z ])
+	    assert_equal([ [], 0, true ], constraint.revise_hyperarc)
+	end
+    end
+end