/// <summary> /// Translates a domain constraint term to an N-ary DD vertex. /// </summary> internal override Vertex TranslateTermToVertex(TermExpr <DomainConstraint <T_Variable, T_Element> > term) { var range = term.Identifier.Range; var domainVariable = term.Identifier.Variable; var domain = domainVariable.Domain; if (range.All(element => !domain.Contains(element))) { // trivially false return(Vertex.Zero); } if (domain.All(element => range.Contains(element))) { // trivially true return(Vertex.One); } // determine assignments for this constraints (if the range contains a value in the domain, '1', else '0') Vertex[] children = domain.Select(element => range.Contains(element) ? Vertex.One : Vertex.Zero).ToArray(); // see if we know this variable int robddVariable; if (!_domainVariableToRobddVariableMap.TryGetValue(domainVariable, out robddVariable)) { robddVariable = Solver.CreateVariable(); _domainVariableToRobddVariableMap[domainVariable] = robddVariable; } // create a new vertex with the given assignments return(Solver.CreateLeafVertex(robddVariable, children)); }
internal override Literal <DomainConstraint <T_Variable, T_Element> > NegateLiteral(Literal <DomainConstraint <T_Variable, T_Element> > literal) { // negate the literal by inverting the range, rather than changing the sign // of the literal TermExpr <DomainConstraint <T_Variable, T_Element> > term = new TermExpr <DomainConstraint <T_Variable, T_Element> >( literal.Term.Identifier.InvertDomainConstraint()); return(new Literal <DomainConstraint <T_Variable, T_Element> >(term, literal.IsTermPositive)); }
internal override Vertex TranslateTermToVertex(TermExpr <T_Identifier> term) { int variable; if (!_variableMap.TryGetValue(term, out variable)) { variable = Solver.CreateVariable(); _variableMap.Add(term, variable); } return(Solver.CreateLeafVertex(variable, Solver.BooleanVariableChildren)); }
internal override IEnumerable <LiteralVertexPair <T_Identifier> > GetSuccessors(Vertex vertex) { LiteralVertexPair <T_Identifier>[] successors = new LiteralVertexPair <T_Identifier> [2]; Debug.Assert(2 == vertex.Children.Length); Vertex then = vertex.Children[0]; Vertex @else = vertex.Children[1]; // get corresponding term expression InitializeInverseVariableMap(); TermExpr <T_Identifier> term = _inverseVariableMap[vertex.Variable]; // add positive successor (then) Literal <T_Identifier> literal = new Literal <T_Identifier>(term, true); successors[0] = new LiteralVertexPair <T_Identifier>(then, literal); // add negative successor (else) literal = literal.MakeNegated(); successors[1] = new LiteralVertexPair <T_Identifier>(@else, literal); return(successors); }
/// <summary> /// Given a term in BoolExpr, returns the corresponding decision diagram vertex. /// </summary> internal abstract Vertex TranslateTermToVertex(TermExpr <T_Identifier> term);
public bool Equals(TermExpr <T_Identifier> other) { return(_comparer.Equals(_identifier, other._identifier)); }
internal override BoolExpr <T_Identifier> VisitTerm(TermExpr <T_Identifier> expression) { return(expression); }
internal abstract T_Return VisitTerm(TermExpr <T_Identifier> expression);
internal override Vertex VisitTerm(TermExpr <T_Identifier> expression) { return(_context.TranslateTermToVertex(expression)); }
internal override BoolExpr <T_To> VisitTerm(TermExpr <T_From> expression) { return(_translator(expression)); }
internal override bool VisitTerm(TermExpr <T_Identifier> expression) { _terms.Add(expression); return(true); }
internal override int VisitTerm(TermExpr <T_Identifier> expression) { return(1); }
internal override BoolExpr <DomainConstraint <T_Variable, T_Element> > VisitTerm(TermExpr <DomainConstraint <T_Variable, T_Element> > expression) { return(new TermExpr <DomainConstraint <T_Variable, T_Element> >(expression.Identifier.InvertDomainConstraint())); }