// ////////////////////////////////////////////////////////////// // inference algorithms /// <summary> /// Implements forward checking. /// </summary> /// <param name="var"></param> /// <param name="assignment"></param> /// <param name="csp"></param> /// <returns></returns> private DomainRestoreInfo DoForwardChecking(Variable var, Assignment assignment, CSProblem csp) { DomainRestoreInfo result = new DomainRestoreInfo(); foreach (IConstraint constraint in csp.GetConstraints(var)) { IList <Variable> scope = constraint.GetScope(); if (scope.Count == 2) { foreach (Variable neighbor in constraint.GetScope()) { if (!assignment.HasAssignmentFor(neighbor)) { if (this.Revise(neighbor, constraint, assignment, csp, result)) { if (csp.GetDomain(neighbor).IsEmpty()) { result.SetEmptyDomainFound(true); return(result); } } } } } } return(result); }
public void RestoreDomains(DomainRestoreInfo info) { foreach (Pair <Variable, Domain> pair in info.SavedDomains) { this.SetDomain(pair.GetFirst(), pair.GetSecond()); } }
private bool Revise(Variable xi, Variable xj, IConstraint constraint, CSProblem csp, DomainRestoreInfo info) { bool revised = false; var assignment = new Assignment(); foreach (object vValue in csp.GetDomain(xi)) { assignment.SetAssignment(xi, vValue); bool vValueOk = false; foreach (var nValue in csp.GetDomain(xj)) { assignment.SetAssignment(xj, nValue); if (constraint.IsSatisfiedWith(assignment)) { vValueOk = true; break; } } if (!vValueOk) { info.StoreDomainFor(xi, csp.GetDomain(xi)); csp.RemoveValueFromDomain(xi, vValue); revised = true; } } return(revised); }
public DomainRestoreInfo ReduceDomains(CSProblem csp) { var result = new DomainRestoreInfo(); var queue = new FIFOQueue <Variable>(); foreach (Variable var in csp.Variables) { queue.Push(var); } this.ReduceDomains(queue, csp, result); return(result.Compactify()); }
private bool Revise(Variable var, IConstraint constraint, Assignment assignment, CSProblem 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 DomainRestoreInfo ReduceDomains(Variable var, object value, CSProblem 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.Push(var); result.StoreDomainFor(var, domain); csp.SetDomain(var, new Domain(new object[] { value })); this.ReduceDomains(queue, csp, result); } } else { result.SetEmptyDomainFound(true); } return(result.Compactify()); }
/// <summary> /// Template method, which can be configured by overriding the three /// primitive operations below. /// </summary> /// <param name="csp"></param> /// <param name="assignment"></param> /// <returns></returns> private Assignment RecursiveBackTrackingSearch(CSProblem csp, Assignment assignment) { Assignment result = null; if (assignment.IsComplete(csp.Variables)) { result = assignment; } else { Variable var = this.SelectUnassignedVariable(assignment, csp); foreach (object value in this.OrderDomainValues(var, assignment, csp)) { assignment.SetAssignment(var, value); this.FireStateChanged(assignment, csp); if (assignment.IsConsistent(csp.GetConstraints(var))) { DomainRestoreInfo info = this.Inference(var, assignment, csp); if (!info.IsEmpty()) { this.FireStateChanged(csp); } if (!info.IsEmptyDomainFound()) { result = this.RecursiveBackTrackingSearch(csp, assignment); if (result != null) { break; } } csp.RestoreDomains(info); } assignment.RemoveAssignment(var); } } return(result); }
protected void ReduceDomains(FIFOQueue <Variable> queue, CSProblem csp, DomainRestoreInfo info) { while (!(queue.Count == 0)) { Variable var = queue.Pop(); foreach (IConstraint constraint in csp.GetConstraints(var)) { if (constraint.GetScope().Count == 2) { Variable neighbor = csp.GetNeighbor(var, constraint); if (this.Revise(neighbor, var, constraint, csp, info)) { if (csp.GetDomain(neighbor).IsEmpty()) { info.SetEmptyDomainFound(true); return; } queue.Push(neighbor); } } } } }