/// @cond DOXYGEN_SHOULD_SKIP_THIS public override bool Equals(object obj) { Substitution s = obj as Substitution; if (s == null) { return(false); } return(Variable.Equals(s.Variable) && SubValue.Equals(s.SubValue)); }
public void AddSubstitution(Substitution s) { Constraint c; bool needsBuild = !m_constraints.TryGetValue(s.Variable, out c); if (s.SubValue.Value.IsVariable) { Constraint c2; if (m_constraints.TryGetValue(s.SubValue.Value, out c2)) { if (needsBuild) { m_constraints[s.Variable] = c2; c2.EquivalentVariables.Add(s.Variable); } else if (!Object.ReferenceEquals(c, c2)) { c2.UnionWith(c); foreach (var v in c2.EquivalentVariables) { m_constraints[v] = c2; } } } else { if (needsBuild) { c = new Constraint(); m_constraints[s.Variable] = c; c.EquivalentVariables.Add(s.Variable); } m_constraints[s.SubValue.Value] = c; c.EquivalentVariables.Add(s.SubValue.Value); } } else { if (needsBuild) { c = new Constraint(); m_constraints[s.Variable] = c; c.EquivalentVariables.Add(s.Variable); } c.Value = s.SubValue.Value; } m_substitutions.Add(s); m_hashIsDirty = true; }
public bool TestConflict(Substitution subs, SubstitutionSet set, out bool canAdd) { canAdd = true; Constraint c; if (!m_constraints.TryGetValue(subs.Variable, out c)) { return(false); } Name G1 = c.Value; Name G2; if (subs.SubValue.Value.IsVariable) { if (c.EquivalentVariables.Contains(subs.SubValue.Value)) { canAdd = false; return(false); } Constraint c2; if (!m_constraints.TryGetValue(subs.SubValue.Value, out c2)) { return(false); } if (c.Value == null || c2.Value == null) { return(false); } G2 = c2.Value; } else { if (G1 == null) { return(false); } canAdd = false; G2 = subs.SubValue.Value; return(!G1.Equals(G2)); //Conflict!!! } G1 = G1.MakeGround(set); G2 = G2.MakeGround(set); return(!G1.Equals(G2)); //Conflict!!! }
//return the idx jump on the valName or -1 if it can't add the substitution private static int FindSubsAux(Literal var, Literal val, SimpleName valName, IDictionary <string, Substitution> bindings) { //first, analyse if the value is a composed name or a single parameter string valDescription; int valLiteralCount; if (val.type == LiteralType.Root) { SimpleName auxName = null; auxName = SimpleWFN.BuildNameFromContainedLiteral(valName, val); valDescription = auxName.ToString(); valLiteralCount = auxName.literals.Count; } else { valDescription = val.description; valLiteralCount = 1; } //check if a binding for the same variable already exists Substitution existingSub = null; bindings.TryGetValue(var.description, out existingSub); if (existingSub != null) { if (existingSub.SubValue.ToString().RemoveWhiteSpace().EqualsIgnoreCase(valDescription)) { return(valLiteralCount); } else { return(-1); } } //if there was no existing binding to the variable try { bindings[var.description] = new Substitution(var.description, valDescription); return(valLiteralCount); } catch (BadSubstitutionException) { return(-1); } }
/// <summary> /// Clone Constructor /// </summary> /// <param name="substitution">The substitution to clone</param> private Substitution(Substitution substitution) { this.Variable = substitution.Variable; this.SubValue = substitution.SubValue; }
private static bool FindSubst(Name n1, Name n2, bool allowPartialTerms, SubstitutionSet bindings) { n1 = n1.MakeGround(bindings); n2 = n2.MakeGround(bindings); var t = GetTerms(n1, n2, allowPartialTerms); if (t == null) { return(false); } foreach (var p in t) { Substitution candidate = null; bool isVar1 = p.Item1.IsVariable; bool isVar2 = p.Item2.IsVariable; // Case 1: x = t, where t is not a variable and x is a variable, and create substitution x/t if (isVar1 != isVar2) { Name variable = (isVar1 ? p.Item1 : p.Item2); Name value = isVar1 ? p.Item2 : p.Item1; if (value.ContainsVariable(variable)) //Occurs check to prevent cyclical evaluations { return(false); } candidate = new Substitution(variable, new ComplexValue(value)); } else if (isVar1) //isVar1 == isVar2 == true { //Case 2: x = x, where x is a variable, ignore it. otherwise add the substitution if (!(p.Item1 == p.Item2)) { candidate = new Substitution(p.Item1, new ComplexValue(p.Item2)); } } else //isVar1 == isVar2 == false { // Case 3: t1 = t2, where t1,t2 are not variables. // If they don't contain variables, compare them to see if they are equal. If they are not equal the unification fails. if (p.Item1.IsGrounded && p.Item2.IsGrounded) { if (p.Item1 == p.Item2) { continue; } if (p.Item1 == Name.UNIVERSAL_SYMBOL || p.Item2 == Name.UNIVERSAL_SYMBOL) { continue; } return(false); } //If one or both contain variables, unify the terms if (!FindSubst(p.Item1, p.Item2, allowPartialTerms, bindings)) { return(false); } } if (candidate != null) { // Step 4: check to see if the newly created substitution conflicts with any of the already created substitution. // If it does, the unification fails. if (!bindings.AddSubstitution(candidate)) { return(false); } } } return(true); }