def intiliazeRandomly(self, csp):
self._assignment = Assignment()
domainLength = len(csp.getListOfDomains())
for va in csp.getVariables():
self._assignment.addVariableToAssignment(
va,
csp.getListOfDomains()[random.randint(0, domainLength - 1)])
def doInference(self, inferenceInfo, csp, variable, value):
self.assignment = Assignment()
self.assignment.addVariableToAssignment(variable, value)
self.varToC = variable
self.valToC = value
queue = csp.getConstraints(variable)
pairs = []
for q in queue:
if len(q.getScope()) == 2:
obj = [q.getScope()[1], q.getScope()[0], q]
pairs.append(obj)
while len(pairs) > 0:
constraint = pairs[0][2]
if self.revise(csp, pairs[0][0], pairs[0][1], constraint):
if len(csp.getDomainValues(pairs[0][0])) == 0:
return None
for con in csp.getNeighboursOfVariableExcept(
pairs[0][0], pairs[0][1]):
if con.getScope(
)[0]._name == variable._name or con.getScope(
)[1]._name == variable._name:
continue
if con.getScope()[0]._name == pairs[0][0]._name:
pairs.append(
[con.getScope()[1],
con.getScope()[0], con])
else:
pairs.append(
[con.getScope()[0],
con.getScope()[1], con])
del pairs[0]
return []
def doInference(self, inferenceInfo, csp, variable, value):
assignment = Assignment()
assignment.addVariableToAssignment(variable, value)
for con in csp.getConstraints(variable):
otherVariables = csp.getNeighbour(variable, con)
for ov in otherVariables:
someValues = []
changed = False
domVals = inferenceInfo.getDomainsOfAffectedVariables(ov)
if domVals is None:
domVals = csp.getDomainValues(ov)
for domVal in domVals:
assignment.addVariableToAssignment(ov, domVal)
if not con.isConsistentWith(assignment):
changed = True
else:
someValues.append(domVal)
if changed:
inferenceInfo.addToAffectedVariables(ov, someValues)
assignment.removeVariableFromAssignment(ov)
return []
class ArcConsistencyInference(object):
'''
classdocs
'''
def __init__(self):
pass
def doInference(self, inferenceInfo, csp, variable, value):
self.assignment = Assignment()
self.assignment.addVariableToAssignment(variable, value)
self.varToC = variable
self.valToC = value
queue = csp.getConstraints(variable)
pairs = []
for q in queue:
if len(q.getScope()) == 2:
obj = [q.getScope()[1], q.getScope()[0], q]
pairs.append(obj)
while len(pairs) > 0:
constraint = pairs[0][2]
if self.revise(csp, pairs[0][0], pairs[0][1], constraint):
if len(csp.getDomainValues(pairs[0][0])) == 0:
return None
for con in csp.getNeighboursOfVariableExcept(
pairs[0][0], pairs[0][1]):
if con.getScope(
)[0]._name == variable._name or con.getScope(
)[1]._name == variable._name:
continue
if con.getScope()[0]._name == pairs[0][0]._name:
pairs.append(
[con.getScope()[1],
con.getScope()[0], con])
else:
pairs.append(
[con.getScope()[0],
con.getScope()[1], con])
del pairs[0]
return []
def revise(self, csp, var1, var2, constraint):
revised = False
dv2Values = []
assignment = Assignment()
assignment.addVariableToAssignment(self.varToC, self.valToC)
if assignment.hasAssignmentFor(var2):
dv2Values.append(self.assignment.getAssignmentOfVariable(var2))
else:
dv2Values = csp.getDomainValues(var2)
for dv1 in csp.getDomainValues(var1):
for dv2 in dv2Values:
if not assignment.hasAssignmentFor(var1):
assignment.addVariableToAssignment(var1, dv1)
assignment.addVariableToAssignment(var1, dv1)
if not assignment.isConsistent([constraint]):
csp.removeValueFromDomain(var1, dv1)
revised = True
return revised
def revise(self, csp, var1, var2, constraint):
revised = False
dv2Values = []
assignment = Assignment()
assignment.addVariableToAssignment(self.varToC, self.valToC)
if assignment.hasAssignmentFor(var2):
dv2Values.append(self.assignment.getAssignmentOfVariable(var2))
else:
dv2Values = csp.getDomainValues(var2)
for dv1 in csp.getDomainValues(var1):
for dv2 in dv2Values:
if not assignment.hasAssignmentFor(var1):
assignment.addVariableToAssignment(var1, dv1)
assignment.addVariableToAssignment(var1, dv1)
if not assignment.isConsistent([constraint]):
csp.removeValueFromDomain(var1, dv1)
revised = True
return revised
class LocalSearch(SearchStrategy):
'''
classdocs
'''
def __init__(self,
inferenceProcdeure,
listeners=[],
variableOrdering=False,
valueOrdering=False,
maxSteps=100000):
'''
Constructor
'''
SearchStrategy.__init__(self, listeners)
self._inferenceProcedure = inferenceProcdeure
self._variableOrdering = variableOrdering
self._valueOrdering = valueOrdering
self._maxSteps = maxSteps
def intiliazeRandomly(self, csp):
self._assignment = Assignment()
domainLength = len(csp.getListOfDomains())
for va in csp.getVariables():
self._assignment.addVariableToAssignment(
va,
csp.getListOfDomains()[random.randint(0, domainLength - 1)])
def solve(self, csp):
self.intiliazeRandomly(csp)
for _ in range(self._maxSteps):
if self._assignment.isSolution(csp):
return self._assignment
cands = self.getConflictedVariable(csp)
var = cands[random.randint(0, len(cands) - 1)]
val = self.getMinConflictValueFor(var, csp)
# print(str(var)+"_"+str(val)+"__"+str(len(cands)))
self.fireListeners(csp, self._assignment)
self._assignment.addVariableToAssignment(var, val)
return False
def getConflictedVariable(self, csp):
resultVariables = []
for con in csp.getListOfConstraints():
if not self._assignment.isConsistent([con]):
for var in con.getScope():
if var not in resultVariables:
resultVariables.append(var)
return resultVariables
def getMinConflictValueFor(self, var, csp):
constraints = csp.getConstraints(var)
assignment = self._assignment.returnCopy()
minConflict = 100000000000
candidates = []
for val in csp.getDomainValues(var):
assignment.addVariableToAssignment(var, val)
count = 0
for con in constraints:
if not assignment.isConsistent([con]):
count += 1
if count <= minConflict:
if count < minConflict:
candidates = []
minConflict = count
candidates.append(val)
return candidates[random.randint(0, len(candidates) - 1)]
def fireListeners(self, csp, assignment):
for listener in self._listeners:
listener.fireChange(csp, assignment)
def solve(self, csp):
return self.recursiveBacktrackingSearch(csp, Assignment())