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 testFailure3(self):
domains = {'x':fd.FiniteDomain((1,)),
'y':fd.FiniteDomain((1,)),
'z':fd.FiniteDomain((2,3)),}
exception = 0
try:
entailed = self.constraint.narrow(domains)
except propagation.ConsistencyFailure:
exception = 1
assert exception
def testNarrowing3(self):
domains = {'x':fd.FiniteDomain((1,)),
'y':fd.FiniteDomain((2,)),
'z':fd.FiniteDomain((1,2,3,4)),}
entailed = self.constraint.narrow(domains)
vx = domains['x'].getValues()
vy = domains['y'].getValues()
vz = domains['z'].getValues()
self.assert_(not entailed)
self.assert_(1 in vx, str(vx))
self.assert_(2 in vy, str(vy))
self.assert_(4 in vz and 3 in vz, str(vz))
def testNarrowing2(self):
domains = {'x':fd.FiniteDomain((1,2)),
'y':fd.FiniteDomain((1,)),
'z':fd.FiniteDomain((1,4)),}
entailed = self.constraint.narrow(domains)
vx = domains['x'].getValues()
vy = domains['y'].getValues()
vz = domains['z'].getValues()
self.assert_(entailed)
self.assert_(2 in vx)
self.assert_(1 in vy)
self.assert_(4 in vz)
def testNarrowing3(self):
domains = {
'x': fd.FiniteDomain((1, )),
'y': fd.FiniteDomain((2, )),
'z': fd.FiniteDomain((1, 2, 3, 4)),
}
entailed = self.constraint.narrow(domains)
vx = domains['x'].getValues()
vy = domains['y'].getValues()
vz = domains['z'].getValues()
self.assertFalse(entailed)
self.assertIn(1, vx)
self.assertIn(2, vy)
self.assertIn(4, vz)
self.assertIn(3, vz)
def setUp(self):
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)
def testNarrowing4(self):
domains = {'x':fd.FiniteDomain((1,)),
'y':fd.FiniteDomain((2,)),
'z':fd.FiniteDomain((1,3,4)),
't':fd.FiniteDomain((2,5,4)),
'u':fd.FiniteDomain((1,2,4)),
}
constraint = fd.AllDistinct(domains.keys())
entailed = constraint.narrow(domains)
vx = domains['x'].getValues()
vy = domains['y'].getValues()
vz = domains['z'].getValues()
vt = domains['t'].getValues()
vu = domains['u'].getValues()
self.failUnless(entailed)
self.assertEquals([1], vx)
self.assertEquals([2], vy)
self.assertEquals([3], vz)
self.assertEquals([5], vt)
self.assertEquals([4], vu)
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 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.AllDistinct(self.relevant_variables)
self.domains = {'x':fd.FiniteDomain((1,2)),
'y':fd.FiniteDomain((1,3)),
'z':fd.FiniteDomain((1,4)),}
self.entailed_domains = {'x':fd.FiniteDomain((1,)),
'y':fd.FiniteDomain((1,2)),
'z':fd.FiniteDomain((1,2,3)),}
def setUp(self):
self.variables = ('v1', 'v2', 'v3')
self.domains1 = {
'v1': fd.FiniteDomain([1]),
'v2': fd.FiniteDomain([2, 3]),
'v3': fd.FiniteDomain([4, 5, 6, 7]),
}
self.domains2 = {
'v1': fd.FiniteDomain([1]),
'v2': fd.FiniteDomain([2, 3, 4, 5, 6]),
'v3': fd.FiniteDomain([7, 8, 9, 10, 11, 12, 13]),
}
self.distributor = self.buildDistributor()
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 setUp(self):
self.values = list(range(3))
self.domain = fd.FiniteDomain(self.values)
def setUp(self):
self.constraint = fd.NotEquals('x',1)
self.domains = {'x':fd.FiniteDomain(range(3))}
def setUp(self):
self.constraint = fd.LesserThan('x',1)
self.domains = {'x':fd.FiniteDomain(range(3))}
def add_var(self, name, values):
self.domains[name] = fd.FiniteDomain(values)
def setUp(self):
self.constraint = fd.GreaterOrEqual('x',1)
self.domains = {'x':fd.FiniteDomain(range(3))}
