// //////////////////////////////////////////////////////////////
// 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);
}
}
}
}
}
