def testInconsistency(self):
self.repo.addConstraint(fd.make_expression(('a', 'b'), 'a < b'))
self.repo.addConstraint(fd.make_expression(('a', 'b'), 'a > b'))
try:
self.repo.consistency()
self.fail('No ConsistencyFailure raised')
except ConsistencyFailure:
pass
def testInconsistency(self):
self.repo.addConstraint(fd.make_expression(('a', 'b'),
'a < b'))
self.repo.addConstraint(fd.make_expression(('a', 'b'),
'a > b'))
try:
self.repo.consistency()
self.fail('No ConsistencyFailure raised')
except ConsistencyFailure:
pass
def testNolutionSolve(self):
self.repo.addConstraint(fd.make_expression(('a', 'b'),
'b < a'))
solutions = self.solver.solve(self.repo)
self.assertEqual(solutions,
[])
def setUp(self):
self.relevant_variables = ['x']
self.irrelevant_variable = 'tagada'
self.constraint = fd.make_expression(self.relevant_variables,
'x==2')
self.domains = {'x':fd.FiniteDomain(range(4))}
self.entailed_domains = {'x':fd.FiniteDomain([2])}
def setUp(self):
self.relevant_variables = ['x']
self.irrelevant_variable = 'tagada'
self.constraint = fd.make_expression(self.relevant_variables,
'x==2')
self.domains = {'x':fd.FiniteDomain(range(4))}
self.entailed_domains = {'x':fd.FiniteDomain([2])}
def testConsistency(self):
for v1 in self.variables:
for v2 in self.variables:
if v1 < v2:
self.repo.addConstraint(fd.make_expression((v1, v2),
'%s < %s'%(v1, v2)))
self.repo.consistency()
for v, dom in self.repo.getDomains().items():
self.assertEqual(dom.size(),1)
def setUp(self):
self.relevant_variables = ['x','y','z']
self.irrelevant_variable = 'tagada'
self.constraint = fd.make_expression(self.relevant_variables,
'x+y==2 and z>1')
self.domains = {'x':fd.FiniteDomain(range(4)),
'y':fd.FiniteDomain(range(3)),
'z':fd.FiniteDomain(range(4))}
self.entailed_domains = {'x':fd.FiniteDomain([2]),
'y':fd.FiniteDomain([0]),
'z':fd.FiniteDomain([2,3]),}
def setUp(self):
self.relevant_variables = ['x','y','z']
self.irrelevant_variable = 'tagada'
self.constraint = fd.make_expression(self.relevant_variables,
'x+y==2 and z>1')
self.domains = {'x':fd.FiniteDomain(range(4)),
'y':fd.FiniteDomain(range(3)),
'z':fd.FiniteDomain(range(4))}
self.entailed_domains = {'x':fd.FiniteDomain([2]),
'y':fd.FiniteDomain([0]),
'z':fd.FiniteDomain([2,3]),}
def setUp(self):
self.solver = Solver()
self.domains = {}
self.variables = list('abcdef')
for v in self.variables:
self.domains[v] = fd.FiniteDomain(range(6))
self.repo = Repository(self.variables, self.domains)
for v1 in self.variables:
for v2 in self.variables:
if v1 < v2:
self.repo.addConstraint(fd.make_expression((v1, v2),
'%s < %s'%(v1, v2)))
def testVCGDraw(self):
for v1 in self.variables:
for v2 in self.variables:
if v1 < v2:
self.repo.addConstraint(fd.make_expression((v1, v2),
'%s < %s'%(v1, v2)))
try:
try:
self.repo.vcg_draw('toto.vcg')
except IOError, exc:
self.fail('This test cannot run in the testing environment'
'because I cannot write the file.\n'
'The error message was: \n%s' % exc)
finally:
os.unlink('toto.vcg')
def queens(size=8, verbose=0):
possible_positions = [(i, j) for i in range(size) for j in range(size)]
variables = []
domains = {}
constraints = []
for i in range(size):
name = 'Q%d' % i
variables.append(name)
domains[name] = fd.FiniteDomain(possible_positions)
for q1 in variables:
for q2 in variables:
if q1 < q2:
constraints.append(fd.make_expression((q1,q2),
'%(q1)s[0] < %(q2)s[0] and '
'%(q1)s[1] != %(q2)s[1] and '
'abs(%(q1)s[0]-%(q2)s[0]) != '
'abs(%(q1)s[1]-%(q2)s[1])'%\
{'q1':q1,'q2':q2}))
r = Repository(variables, domains, constraints)
s = Solver().solve(r, verbose)
print 'Number of solutions:', len(s)
def queens(size=8,verbose=0):
possible_positions = [(i,j) for i in range(size) for j in range(size)]
variables = []
domains = {}
constraints = []
for i in range(size):
name = 'Q%d'%i
variables.append(name)
domains[name] = fd.FiniteDomain(possible_positions)
for q1 in variables:
for q2 in variables:
if q1 < q2:
constraints.append(fd.make_expression((q1,q2),
'%(q1)s[0] < %(q2)s[0] and '
'%(q1)s[1] != %(q2)s[1] and '
'abs(%(q1)s[0]-%(q2)s[0]) != '
'abs(%(q1)s[1]-%(q2)s[1])'%\
{'q1':q1,'q2':q2}))
r = Repository(variables,domains,constraints)
s = Solver().solve(r,verbose)
print 'Number of solutions:',len(s)
def parseHead(self,kepthead,removedhead,rule):
try:
kepthead = self.splitHead(kepthead)
rule.kepthead = [self.rulesystem.bcfactory.getFreeConstraint(func,args) for (func,args) in kepthead]
removedhead = self.splitHead(removedhead)
rule.removedhead = [self.rulesystem.bcfactory.getFreeConstraint(func,args) for (func,args) in removedhead]
except KeyError:
logging.getLogger("rulesystem.parse").error("Constraint not found when parsing rules, did you list all constraints in the [Constraints] section?")
raise
head = kepthead + removedhead
for (i,(functor,args)) in enumerate(head):
types = self.rulesystem.bcfactory.getFreeConstraint(functor,args).types
for (j,arg) in enumerate(args):
if arg[0].isupper():
if not arg in rule.extravars:
rule.extravars.append(arg)
rule.guard.append(fd.make_expression(("_var_%i_%i"%(i,j),arg),"_var_%i_%i == %s"%(i,j,arg)))
elif arg[0] == "_":
continue
else:
rule.guard.append(fd.Equals("_var_%i_%i"%(i,j),totype(arg,types[j])))
def add_expr(self, vars, expr):
self.constraints.append(fd.make_expression(vars, expr))
self.scons.append(expr)
def matchAtPosition(self,con,pos):
allConstraints = self.kepthead + self.removedhead
var1 = ["_var_%i" % i for i in range(len(allConstraints))]
var2 = ["_var_%i_%i" % (i,j) for i in range(len(allConstraints)) for j in range(allConstraints[i].arity)]
domains = {}
allvals = []
for i in range(len(allConstraints)):
c = "_var_%i" % i
vals = self.rulesystem.findConstraint(allConstraints[i])
if vals == []:
return False
domains[c] = fd.FiniteDomain(vals)
for j in range(allConstraints[i].arity):
c2 = "%s_%i" % (c,j)
vals2 = [x.args[j] for x in vals]
domains[c2] = fd.FiniteDomain(vals2)
allvals.extend(vals2)
for i in self.extravars:
domains[i] = fd.FiniteDomain(allvals)
variables = var1 + var2 + self.extravars
constraints = []
if(len(var1) > 1):
constraints.append(fd.AllDistinct(var1))
constraints.append(fd.Equals("_var_%i" % pos,con))
for i in range(len(allConstraints)):
for j in range(allConstraints[i].arity):
c = "_var_%i" % i
a = "_var_%i_%i" % (i,j)
constraints.append(fd.make_expression((c,a),"%s.args[%i] == %s"%(c,j,a)))
constraints.extend(self.guard)
try:
#logging.getLogger("rulesystem.matchAtPosition").debug("vars " + str(variables))
#logging.getLogger("rulesystem.matchAtPosition").debug("domains " + str(domains))
#logging.getLogger("rulesystem.matchAtPosition").debug("cons " + str(constraints))
r = Repository(variables, domains, constraints)
solutions = Solver().solve(r, self.rulesystem.verbosity > 2 and self.rulesystem.verbosity - 2)
except ConsistencyFailure:
return False
if solutions is None:
return False
for solution in solutions:
p = [solution["_var_%i"%i] for i in range(len(allConstraints))]
assert len(p) == len(self.kepthead) + len(self.removedhead)
if tuple(p) in self.history: continue
if self.rulesystem.hasConstraints(p):
context = self.rulesystem.createContext()
#bind vars
for i in range(len(p)):
tempcon = p[i]
for j in range(tempcon.arity):
var = "_var_%i_%i" % (i,j)
context[var] = tempcon.args[j]
for v in self.extravars:
context[v] = solution[v]
if eval(self.userguard,context):
#logging.getLogger("rulesystem.matchAtPosition").info("Fired:%s" % self.name)
if self.removedhead == []:
removedConstraints = []
else:
removedConstraints = p[-len(self.removedhead):]
for c in removedConstraints:
self.rulesystem.removeConstraint(c)
self.history.add(tuple(p))
try:
exec(self.body,context)
except NameError:
#logging.getLogger("rulesystem.matchAtPosition").error("Variable, function or constraint not found, please check rule '%s'"%self.name)
raise
