/// <summary>
/// Initialize a new literal.
/// </summary>
/// <param name="term"> Term </param>
/// <param name="isTermPositive"> Sign of term </param>
internal Literal(TermExpr <T_Identifier> term, bool isTermPositive)
: base(isTermPositive ? term : (BoolExpr <T_Identifier>) new NotExpr <T_Identifier>(term))
{
DebugCheck.NotNull(term);
_term = term;
_isTermPositive = isTermPositive;
}
/// <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')
var 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
var 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 bool VisitTerm(TermExpr <T_Identifier> expression)
{
_terms.Add(expression);
return(true);
}
public bool Equals(TermExpr <T_Identifier> other)
{
return(this._comparer.Equals(this._identifier, other._identifier));
}
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 BoolExpr <T_Identifier> VisitTerm(TermExpr <T_Identifier> expression)
{
return(new NotExpr <T_Identifier>(expression));
}
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()));
}
/// <summary> /// Given a term in BoolExpr, returns the corresponding decision diagram vertex. /// </summary> internal abstract Vertex TranslateTermToVertex(TermExpr <T_Identifier> term);
internal override BoolExpr <T_Identifier> VisitTerm(TermExpr <T_Identifier> expression)
{
return((BoolExpr <T_Identifier>)expression);
}
internal override int VisitTerm(TermExpr <T_Identifier> expression)
{
return(1);
}
