/** * Template method, which can be configured by overriding the three * primitive operations below. */ private Assignment recursiveBackTrackingSearch(CSP csp, Assignment assignment) { Assignment result = null; if (assignment.isComplete(csp.getVariables())) { result = assignment; } else { Variable var = selectUnassignedVariable(assignment, csp); foreach (Object value in orderDomainValues(var, assignment, csp)) { assignment.setAssignment(var, value); fireStateChanged(assignment, csp); if (assignment.isConsistent(csp.getConstraints(var))) { DomainRestoreInfo info = inference(var, assignment, csp); if (!info.isEmpty()) fireStateChanged(csp); if (!info.isEmptyDomainFound()) { result = recursiveBackTrackingSearch(csp, assignment); if (result != null) break; } info.restoreDomains(csp); } assignment.removeAssignment(var); } } return result; }
/** * Makes a CSP consisting of binary constraints arc-consistent. * @return An object which indicates success/failure and contains * data to undo the operation. */ public DomainRestoreInfo reduceDomains(CSP csp) { DomainRestoreInfo result = new DomainRestoreInfo(); FIFOQueue<Variable> queue = new FIFOQueue<Variable>(); foreach (Variable var in csp.getVariables()) queue.Add(var); reduceDomains(queue, csp, result); return result.compactify(); }
private Assignment generateRandomAssignment(CSP csp) { Assignment assignment = new Assignment(); foreach (Variable var in csp.getVariables()) { Object randomValue = Util.selectRandomlyFromList(csp.getDomain(var) .asList()); assignment.setAssignment(var, randomValue); } return assignment; }
private List<Variable> getConflictedVariables(Assignment assignment, CSP csp) { List<Variable> result = new List<Variable>(); foreach (Constraint constraint in csp.getConstraints()) { if (!constraint.isSatisfiedWith(assignment)) foreach (Variable var in constraint.getScope()) if (!result.contains(var)) result.Add(var); } return result; }
/** * Starts with a constraint propagation if AC-3 is enabled and then calls * the super class implementation. */ public Assignment solve(CSP csp) { if (inferenceStrategy == Inference.AC3) { DomainRestoreInfo info = new AC3Strategy().reduceDomains(csp); if (!info.isEmpty()) { fireStateChanged(csp); if (info.isEmptyDomainFound()) return null; } } return super.solve(csp); }
private bool revise(Variable var, Constraint constraint, Assignment assignment, CSP csp, DomainRestoreInfo info) { bool revised = false; foreach (Object value in csp.getDomain(var)) { assignment.setAssignment(var, value); if (!constraint.isSatisfiedWith(assignment)) { info.storeDomainFor(var, csp.getDomain(var)); csp.removeValueFromDomain(var, value); revised = true; } assignment.removeAssignment(var); } return(revised); }
/** * Primitive operation, selecting a not yet assigned variable. */ protected override Variable selectUnassignedVariable(Assignment assignment, CSP csp) { switch (selectionStrategy) { case MRV: return applyMRVHeuristic(csp, assignment).get(0); case MRV_DEG: List<Variable> vars = applyMRVHeuristic(csp, assignment); return applyDegreeHeuristic(vars, assignment, csp).get(0); default: foreach (Variable var in csp.getVariables()) { if (!(assignment.hasAssignmentFor(var))) return var; } } return null; }
private List <Variable> getConflictedVariables(Assignment assignment, CSP csp) { List <Variable> result = new List <Variable>(); foreach (Constraint constraint in csp.getConstraints()) { if (!constraint.isSatisfiedWith(assignment)) { foreach (Variable var in constraint.getScope()) { if (!result.contains(var)) { result.Add(var); } } } } return(result); }
private int countLostValues(Variable var, Object value, CSP csp) { int result = 0; Assignment assignment = new Assignment(); assignment.setAssignment(var, value); foreach (Constraint constraint in csp.getConstraints(var)) { Variable neighbor = csp.getNeighbor(var, constraint); foreach (Object nValue in csp.getDomain(neighbor)) { assignment.setAssignment(neighbor, nValue); if (!constraint.isSatisfiedWith(assignment)) { ++result; } } } return(result); }
/** * Reduces the domain of the specified variable to the specified * value and reestablishes arc-consistency. It is assumed that the * provided CSP is arc-consistent before the call. * @return An object which indicates success/failure and contains * data to undo the operation. */ public DomainRestoreInfo reduceDomains(Variable var, Object value, CSP csp) { DomainRestoreInfo result = new DomainRestoreInfo(); Domain domain = csp.getDomain(var); if (domain.contains(value)) { if (domain.Count > 1) { FIFOQueue<Variable> queue = new FIFOQueue<Variable>(); queue.Add(var); result.storeDomainFor(var, domain); csp.setDomain(var, new Domain(new Object[] { value })); reduceDomains(queue, csp, result); } } else { result.setEmptyDomainFound(true); } return result.compactify(); }
public Assignment solve(CSP csp) { Assignment assignment = generateRandomAssignment(csp); fireStateChanged(assignment, csp); for (int i = 0; i < maxSteps; i++) { if (assignment.isSolution(csp)) { return assignment; } else { List<Variable> vars = getConflictedVariables(assignment, csp); Variable var = Util.selectRandomlyFromList(vars); Object value = getMinConflictValueFor(var, assignment, csp); assignment.setAssignment(var, value); fireStateChanged(assignment, csp); } } return null; }
/** * Primitive operation, selecting a not yet assigned variable. */ protected override Variable selectUnassignedVariable(Assignment assignment, CSP csp) { switch (selectionStrategy) { case MRV: return(applyMRVHeuristic(csp, assignment).get(0)); case MRV_DEG: List <Variable> vars = applyMRVHeuristic(csp, assignment); return(applyDegreeHeuristic(vars, assignment, csp).get(0)); default: foreach (Variable var in csp.getVariables()) { if (!(assignment.hasAssignmentFor(var))) { return(var); } } } return(null); }
public Assignment solve(CSP csp) { Assignment assignment = generateRandomAssignment(csp); fireStateChanged(assignment, csp); for (int i = 0; i < maxSteps; i++) { if (assignment.isSolution(csp)) { return(assignment); } else { List <Variable> vars = getConflictedVariables(assignment, csp); Variable var = Util.selectRandomlyFromList(vars); Object value = getMinConflictValueFor(var, assignment, csp); assignment.setAssignment(var, value); fireStateChanged(assignment, csp); } } return(null); }
/** * Reduces the domain of the specified variable to the specified * value and reestablishes arc-consistency. It is assumed that the * provided CSP is arc-consistent before the call. * @return An object which indicates success/failure and contains * data to undo the operation. */ public DomainRestoreInfo reduceDomains(Variable var, Object value, CSP csp) { DomainRestoreInfo result = new DomainRestoreInfo(); Domain domain = csp.getDomain(var); if (domain.contains(value)) { if (domain.Count > 1) { FIFOQueue <Variable> queue = new FIFOQueue <Variable>(); queue.Add(var); result.storeDomainFor(var, domain); csp.setDomain(var, new Domain(new Object[] { value })); reduceDomains(queue, csp, result); } } else { result.setEmptyDomainFound(true); } return(result.compactify()); }
/** * Template method, which can be configured by overriding the three * primitive operations below. */ private Assignment recursiveBackTrackingSearch(CSP csp, Assignment assignment) { Assignment result = null; if (assignment.isComplete(csp.getVariables())) { result = assignment; } else { Variable var = selectUnassignedVariable(assignment, csp); foreach (Object value in orderDomainValues(var, assignment, csp)) { assignment.setAssignment(var, value); fireStateChanged(assignment, csp); if (assignment.isConsistent(csp.getConstraints(var))) { DomainRestoreInfo info = inference(var, assignment, csp); if (!info.isEmpty()) { fireStateChanged(csp); } if (!info.isEmptyDomainFound()) { result = recursiveBackTrackingSearch(csp, assignment); if (result != null) { break; } } info.restoreDomains(csp); } assignment.removeAssignment(var); } } return(result); }
// ////////////////////////////////////////////////////////////// // heuristics for selecting the next unassigned variable and domain ordering /** : the minimum-remaining-values heuristic. */ private List <Variable> applyMRVHeuristic(CSP csp, Assignment assignment) { List <Variable> result = new List <Variable>(); int mrv = int.MAX_VALUE; foreach (Variable var in csp.getVariables()) { if (!assignment.hasAssignmentFor(var)) { int num = csp.getDomain(var).Count; if (num <= mrv) { if (num < mrv) { result.clear(); mrv = num; } result.Add(var); } } } return(result); }
private void reduceDomains(FIFOQueue <Variable> queue, CSP csp, DomainRestoreInfo info) { while (!queue.isEmpty()) { Variable var = queue.pop(); foreach (Constraint constraint in csp.getConstraints(var)) { if (constraint.getScope().Count == 2) { Variable neighbor = csp.getNeighbor(var, constraint); if (revise(neighbor, var, constraint, csp, info)) { if (csp.getDomain(neighbor).isEmpty()) { info.setEmptyDomainFound(true); return; } queue.push(neighbor); } } } } }
public void restoreDomains(CSP csp) { foreach (Pair<Variable, Domain> pair in getSavedDomains()) csp.setDomain(pair.getFirst(), pair.getSecond()); }
public abstract Assignment solve(CSP csp);
protected void fireStateChanged(Assignment assignment, CSP csp) { foreach (CSPStateListener listener in listeners) listener.stateChanged(assignment.copy(), csp.copyDomains()); }
protected void fireStateChanged(CSP csp) { foreach (CSPStateListener listener in listeners) listener.stateChanged(csp.copyDomains()); }
/** * Returns true if this assignment is consistent as well as complete with * respect to the given CSP. */ public bool isSolution(CSP csp) { return isConsistent(csp.getConstraints()) && isComplete(csp.getVariables()); }
/** : the degree heuristic. */ private List<Variable> applyDegreeHeuristic(List<Variable> vars, Assignment assignment, CSP csp) { List<Variable> result = new List<Variable>(); int maxDegree = int.MIN_VALUE; foreach (Variable var in vars) { int degree = 0; foreach (Constraint constraint in csp.getConstraints(var)) { Variable neighbor = csp.getNeighbor(var, constraint); if (!assignment.hasAssignmentFor(neighbor) && csp.getDomain(neighbor).Count > 1) ++degree; } if (degree >= maxDegree) { if (degree > maxDegree) { result.clear(); maxDegree = degree; } result.Add(var); } } return result; }
private Object getMinConflictValueFor(Variable var, Assignment assignment, CSP csp) { List<Constraint> constraints = csp.getConstraints(var); Assignment duplicate = assignment.copy(); int minConflict = int.MAX_VALUE; List<Object> resultCandidates = new List<Object>(); foreach (Object value in csp.getDomain(var)) { duplicate.setAssignment(var, value); int currConflict = countConflicts(duplicate, constraints); if (currConflict <= minConflict) { if (currConflict < minConflict) { resultCandidates.clear(); minConflict = currConflict; } resultCandidates.Add(value); } } if (!resultCandidates.isEmpty()) return Util.selectRandomlyFromList(resultCandidates); else return null; }
/** * Primitive operation, ordering the domain values of the specified * variable. This default implementation just takes the default order * provided by the CSP. */ protected Iterable? orderDomainValues(Variable var, Assignment assignment, CSP csp) { return csp.getDomain(var); }
/** * Returns true if this assignment is consistent as well as complete with * respect to the given CSP. */ public bool isSolution(CSP csp) { return(isConsistent(csp.getConstraints()) && isComplete(csp.getVariables())); }
/** * Primitive operation, ordering the domain values of the specified * variable. This default implementation just takes the default order * provided by the CSP. */ protected Iterable?orderDomainValues(Variable var, Assignment assignment, CSP csp) { return(csp.getDomain(var)); }
/** * Primitive operation, selecting a not yet assigned variable. This default * implementation just selects the first in the ordered list of variables * provided by the CSP. */ protected Variable selectUnassignedVariable(Assignment assignment, CSP csp) { foreach (Variable var in csp.getVariables()) { if (!(assignment.hasAssignmentFor(var))) return var; } return null; }
private bool revise(Variable var, Constraint constraint, Assignment assignment, CSP csp, DomainRestoreInfo info) { bool revised = false; foreach (Object value in csp.getDomain(var)) { assignment.setAssignment(var, value); if (!constraint.isSatisfiedWith(assignment)) { info.storeDomainFor(var, csp.getDomain(var)); csp.removeValueFromDomain(var, value); revised = true; } assignment.removeAssignment(var); } return revised; }
public Assignment solve(CSP csp) { return recursiveBackTrackingSearch(csp, new Assignment()); }
/** * Primitive operation, which tries to prune out values from the CSP which * are not possible anymore when extending the given assignment to a * solution. This default implementation just leaves the original CSP as it * is. * * @return An object which provides informations about (1) whether changes * have been performed, (2) possibly inferred empty domains , and * (3) how to restore the domains. */ protected DomainRestoreInfo inference(Variable var, Assignment assignment, CSP csp) { return new DomainRestoreInfo().compactify(); }
/** : the least constraining value heuristic. */ private List<Object> applyLeastConstrainingValueHeuristic(Variable var, CSP csp) { List<Pair<Object, int>> pairs = new List<Pair<Object, int>>(); foreach (Object value in csp.getDomain(var)) { int num = countLostValues(var, value, csp); pairs.Add(new Pair<Object, int>(value, num)); } // TODO //Collections.sort(pairs, new Comparator<Pair<Object, int>>() { // public int compare(Pair<Object, int> o1, // Pair<Object, int> o2) { // return o1.getSecond() < o2.getSecond() ? -1 // : o1.getSecond() > o2.getSecond() ? 1 : 0; // } //}); List<Object> result = new List<Object>(); foreach (Pair<Object, int> pair in pairs) result.Add(pair.getFirst()); return result; }
private bool revise(Variable xi, Variable xj, Constraint constraint, CSP csp, DomainRestoreInfo info) { bool revised = false; Assignment assignment = new Assignment(); foreach (Object iValue in csp.getDomain(xi)) { assignment.setAssignment(xi, iValue); bool consistentExtensionFound = false; foreach (Object jValue in csp.getDomain(xj)) { assignment.setAssignment(xj, jValue); if (constraint.isSatisfiedWith(assignment)) { consistentExtensionFound = true; break; } } if (!consistentExtensionFound) { info.storeDomainFor(xi, csp.getDomain(xi)); csp.removeValueFromDomain(xi, iValue); revised = true; } } return revised; }
// ////////////////////////////////////////////////////////////// // heuristics for selecting the next unassigned variable and domain ordering /** : the minimum-remaining-values heuristic. */ private List<Variable> applyMRVHeuristic(CSP csp, Assignment assignment) { List<Variable> result = new List<Variable>(); int mrv = int.MAX_VALUE; foreach (Variable var in csp.getVariables()) { if (!assignment.hasAssignmentFor(var)) { int num = csp.getDomain(var).Count; if (num <= mrv) { if (num < mrv) { result.clear(); mrv = num; } result.Add(var); } } } return result; }
// ////////////////////////////////////////////////////////////// // inference algorithms /** : forward checking. */ private DomainRestoreInfo doForwardChecking(Variable var, Assignment assignment, CSP csp) { DomainRestoreInfo result = new DomainRestoreInfo(); foreach (Constraint constraint in csp.getConstraints(var)) { List<Variable> scope = constraint.getScope(); if (scope.Count == 2) { foreach (Variable neighbor in constraint.getScope()) { if (!assignment.hasAssignmentFor(neighbor)) { if (revise(neighbor, constraint, assignment, csp, result)) { if (csp.getDomain(neighbor).isEmpty()) { result.setEmptyDomainFound(true); return result; } } } } } } return result; }
/** * Returns a copy which contains a copy of the domains list and is in all * other aspects a flat copy of this. */ public CSP copyDomains() { CSP result = new CSP(); result.variables = variables; result.domains = new List<Domain>(domains.Count); result.domains.AddRange(domains); result.constraints = constraints; result.varIndexHash = varIndexHash; result.cnet = cnet; return result; }
private int countLostValues(Variable var, Object value, CSP csp) { int result = 0; Assignment assignment = new Assignment(); assignment.setAssignment(var, value); foreach (Constraint constraint in csp.getConstraints(var)) { Variable neighbor = csp.getNeighbor(var, constraint); foreach (Object nValue in csp.getDomain(neighbor)) { assignment.setAssignment(neighbor, nValue); if (!constraint.isSatisfiedWith(assignment)) { ++result; } } } return result; }
/** * Primitive operation, which tries to prune out values from the CSP which * are not possible anymore when extending the given assignment to a * solution. * * @return An object which provides informations about (1) whether changes * have been performed, (2) possibly inferred empty domains , and * (3) how to restore the domains. */ protected override DomainRestoreInfo inference(Variable var, Assignment assignment, CSP csp) { switch (inferenceStrategy) { case FORWARD_CHECKING: return doForwardChecking(var, assignment, csp); case AC3: return new AC3Strategy().reduceDomains(var, assignment .getAssignment(var), csp); default: return new DomainRestoreInfo().compactify(); } }
private void reduceDomains(FIFOQueue<Variable> queue, CSP csp, DomainRestoreInfo info) { while (!queue.isEmpty()) { Variable var = queue.pop(); foreach (Constraint constraint in csp.getConstraints(var)) { if (constraint.getScope().Count == 2) { Variable neighbor = csp.getNeighbor(var, constraint); if (revise(neighbor, var, constraint, csp, info)) { if (csp.getDomain(neighbor).isEmpty()) { info.setEmptyDomainFound(true); return; } queue.push(neighbor); } } } } }
/** * Primitive operation, which tries to prune out values from the CSP which * are not possible anymore when extending the given assignment to a * solution. This default implementation just leaves the original CSP as it * is. * * @return An object which provides informations about (1) whether changes * have been performed, (2) possibly inferred empty domains , and * (3) how to restore the domains. */ protected DomainRestoreInfo inference(Variable var, Assignment assignment, CSP csp) { return(new DomainRestoreInfo().compactify()); }
/** * Primitive operation, ordering the domain values of the specified * variable. */ protected override Iterable? orderDomainValues(Variable var, Assignment assignment, CSP csp) { if (!isLCVHeuristicEnabled) { return csp.getDomain(var); } else { return applyLeastConstrainingValueHeuristic(var, csp); } }
public Assignment solve(CSP csp) { return(recursiveBackTrackingSearch(csp, new Assignment())); }
public abstract Assignment solve(CSP csp);