def _valueRemoved(self):
if self.lowestMin >= self.highestMax:
raise ConsistencyFailure("earliest start [%.2f] higher than latest end [%.2f]" %
(self.lowestMin, self.highestMax))
if self._min_length > self._max_length:
raise ConsistencyFailure("min length [%.2f] greater than max length [%.2f]" %
(self._min_length, self._max_length))
self._max_length = min(self._max_length, self.highestMax - self.lowestMin)
AbstractDomain._valueRemoved(self)
def narrow(self, domains):
"""narrowing algorithm for the constraint"""
variables = [(domains[variable].size(), variable, domains[variable])
for variable in self._variables]
variables.sort()
# if a domain has a size of 1,
# then the value must be removed from the other domains
for size, var, dom in variables:
if dom.size() == 1:
for _siz, _var, _dom in variables:
if _var != var:
try:
_dom.removeValue(dom.getValues()[0])
except KeyError:
# we ignore errors caused by the removal of
# non existing values
pass
# if there are less values than variables, the constraint fails
values = {}
for size, var, dom in variables:
for val in dom:
values[val] = 0
if len(values) < len(variables):
raise ConsistencyFailure()
# the constraint is entailed if all domains have a size of 1
for variable in variables:
if variable[2].size() != 1:
return 0
return 1
def narrow(self, domains):
"""generic narrowing algorithm for n-ary expressions"""
maybe_entailed = 1
ffunc = self.filterFunc
result_cache = self._init_result_cache()
for kwargs in self._assign_values(domains):
if maybe_entailed:
for var, val in kwargs.iteritems():
if val not in result_cache[var]:
break
else:
continue
if ffunc(**kwargs):
for var, val in kwargs.items():
result_cache[var][val] = 1
else:
maybe_entailed = 0
try:
for var, keep in result_cache.iteritems():
domain = domains[var]
domain.removeValues([val for val in domain if val not in keep])
except ConsistencyFailure:
raise ConsistencyFailure('Inconsistency while applying %s' % \
repr(self))
except KeyError:
# There are no more value in result_cache
pass
return maybe_entailed
def narrow(self,domains):
domain = domains[self._variable]
try:
for v in domain.getValues():
s = str(v)
for d in ('0','1','2','3','4','5','6','7','8','9'):
if s.count(d) not in (0,1):
domain.removeValue(v)
break
except ConsistencyFailure, e:
raise ConsistencyFailure('inconsistency while applying %s'%repr(self))
def narrow(self, domains):
"""specialized narrowing algorithm for binary expressions
Runs much faster than the generic version"""
maybe_entailed = 1
var1 = self._variables[0]
dom1 = domains[var1]
values1 = dom1.getValues()
var2 = self._variables[1]
dom2 = domains[var2]
values2 = dom2.getValues()
ffunc = self.filterFunc
if dom2.size() < dom1.size():
var1, var2 = var2, var1
dom1, dom2 = dom2, dom1
values1, values2 = values2, values1
kwargs = {}
keep1 = {}
keep2 = {}
maybe_entailed = 1
try:
# iterate for all values
for val1 in values1:
kwargs[var1] = val1
for val2 in values2:
kwargs[var2] = val2
if val1 in keep1 and val2 in keep2 and maybe_entailed == 0:
continue
if ffunc(**kwargs):
keep1[val1] = 1
keep2[val2] = 1
else:
maybe_entailed = 0
dom1.removeValues([val for val in values1 if val not in keep1])
dom2.removeValues([val for val in values2 if val not in keep2])
except ConsistencyFailure:
raise ConsistencyFailure('Inconsistency while applying %s' % \
repr(self))
except Exception:
print self, kwargs
raise
return maybe_entailed
def narrow(self, domains):
maybe_entailed = 1
var1 = self._variables[0]
dom1 = domains[var1]
values1 = dom1.getValues()
var2 = self._variables[1]
dom2 = domains[var2]
values2 = dom2.getValues()
keep1 = {}
keep2 = {}
maybe_entailed = 1
for val1 in values1:
val1_0 = val1[0]
val1_1 = val1[1]
for val2 in values2:
if val1 in keep1 and val2 in keep2 and maybe_entailed == 0:
continue
val2_0 = val2[0]
val2_1 = val2[1]
if val1_0 < val2_0 and \
val1_1 != val2_1 and \
abs(val1_0-val2_0) != abs(val1_1-val2_1):
keep1[val1] = 1
keep2[val2] = 1
else:
maybe_entailed = 0
try:
dom1.removeValues([val for val in values1 if val not in keep1])
dom2.removeValues([val for val in values2 if val not in keep2])
except ConsistencyFailure:
raise ConsistencyFailure('Inconsistency while applying %s' % \
repr(self))
except Exception:
print self, kwargs
raise
return maybe_entailed