/// <summary>
/// Determines whether this Multiset is disjoint with another Multiset.
/// </summary>
/// <param name="other">Other Multiset.</param>
/// <returns></returns>
public override bool IsDisjointWith(BaseMultiset other)
{
if (other is IdentityMultiset || other is NullMultiset)
{
return(false);
}
return(Variables.All(v => !other.ContainsVariable(v)));
}
private void Validate()
{
var errors = new List <ValidationFailure>();
foreach (var result in Variables.Select(variable => new VariableValidator <T>().Validate(variable)).Where(result => !result.IsValid))
{
errors.AddRange(result.Errors.ToList());
}
foreach (var result in Domains.Select(domain => new DomainValidator <T>().Validate(domain)).Where(result => !result.IsValid))
{
errors.AddRange(result.Errors.ToList());
}
foreach (var result in Relations.Select(relation => new RelationsValidator <T>().Validate(relation)).Where(result => !result.IsValid))
{
errors.AddRange(result.Errors.ToList());
}
foreach (var result in Constraints.Select(constraint => new ConstraintValidator <T>().Validate(constraint)).Where(result => !result.IsValid))
{
errors.AddRange(result.Errors.ToList());
}
if (errors.Any())
{
throw new ArgumentException(errors.Select(e => e.ErrorMessage).Aggregate((a, b) => $"{a},{b}"));
}
if (Relations.Any(r => Variables.All(v => v.Key != r.Key)))
{
throw new ArgumentException("Relationships/Variables mismatch");
}
if (Relations.Any(r => r.Values.Any(rv => Variables.All(v => v.Key != rv.Key))))
{
throw new ArgumentException("Relationships/Variables mismatch");
}
if (Domains.Any(d => !d.Values.Any()))
{
throw new ArgumentException("Domain start size cannot be zero");
}
}
public FluentEmitter Ldloc(params VariableDefinition[] vars)
{
if (vars == null)
{
throw new ArgumentNullException(nameof(vars));
}
foreach (var var in vars)
{
if (var == null)
{
throw new ArgumentNullException($"variable is null");
}
if (Variables.All(v => v != var))
{
throw new ArgumentException("variable must be declared in method body before using it");
}
Ldloc((uint)var.Index);
}
return(this);
}
public override bool IsConstantExpression()
{
return(Variables.All(i => i.From.IsConstantExpression() && i.To.IsConstantExpression()) && Body.IsConstantExpression());
}
public override bool CheckValidity()
{
return(Variables.All(x => x.IsValid));
}
// int => indeks variabla, int - indeks wartosci z dziedziny
protected bool FindSolutionForwardChecking(int variableIndex)
{
var values = Variables[variableIndex].MaskedDomain;
foreach (var val in values)
{
Variables[variableIndex].Current = val;
Counter++;
if (Constraints.All(con => con.Check.Invoke()))
{
if (Variables.All(v => v.Current != null))
{
OnSolutionFound?.Invoke(Variables);
return(true);
}
// prune
var neighborVariables = new List <(IVariable <T>, BinaryConstraint <T>)>();
Constraints.ForEach(c =>
{
var cast = c as BinaryConstraint <T>;
if (cast != null && cast.VariableA == Variables[variableIndex])
{
neighborVariables.Add((cast.VariableB, cast));
}
if (cast != null && cast.VariableB == Variables[variableIndex])
{
neighborVariables.Add((cast.VariableA, cast));
}
});
neighborVariables = neighborVariables.Where(v => v.Item1.Current == null).ToList();
var prunedValues = new List <(int, int)>();
foreach (var pair in neighborVariables)
{
int idx = Variables.IndexOf(pair.Item1);
var variable = Variables[idx];
if (variable.Current == null)
{
for (int i = 0; i < variable.Domain.Count; i++)
{
if (variable.DomainMask[i])
{
variable.Current = variable.Domain[i];
//counter++;
if (!pair.Item2.Check())
{
variable.DomainMask[i] = false;
prunedValues.Add((idx, i));
}
variable.Current = default;
}
}
pair.Item1.Current = default;
}
}
// end of prune
// HEURISTICS
int newIndex;
#if H_DOM_SIZE
var chosenVar = Variables
.Where(v => v.Current == null)
.OrderBy(v => v.MaskedDomain.Count)
.First();
newIndex = Variables.IndexOf(chosenVar);
#elif H_MCV
var chosenVar = Variables
.Where(v => v.Current == null)
.OrderBy(v => Constraints.Sum(c =>
{
var cast = c as BinaryConstraint <T>;
if (cast == null)
{
return(0);
}
else if (cast.VariableA == v || cast.VariableB == v)
{
return(1);
}
return(0);
}))
.First();
newIndex = Variables.IndexOf(chosenVar);
#elif H_LCV
var chosenVar = Variables
.Where(v => v.Current == null)
.OrderByDescending(v => Constraints.Sum(c =>
{
var cast = c as BinaryConstraint <T>;
if (cast == null)
{
return(0);
}
else if (cast.VariableA == v || cast.VariableB == v)
{
return(1);
}
return(0);
}))
.First();
newIndex = Variables.IndexOf(chosenVar);
#else
newIndex = variableIndex + 1;
#endif
var solutionFound = FindSolutionForwardChecking(newIndex);
if (solutionFound)
{
return(true);
}
else
{
// revert prune
foreach (var pair in prunedValues)
{
Variables[pair.Item1].DomainMask[pair.Item2] = true;
}
// end of revert prune
}
}
else
{
Variables[variableIndex].Current = default;
}
}
Variables[variableIndex].Current = default;
return(false);
}
