/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public void Visit(AndExpression expression)
{
foreach (var subExpression in expression.Children)
{
subExpression.Accept(this);
}
}
/// <summary>
/// Visits and transforms the expression.
/// </summary>
/// <param name="expression">Source expression.</param>
/// <returns>Transformed expression.</returns>
public IExpression Visit(AndExpression expression)
{
List <IExpression> arguments = new List <IExpression>();
expression.Children.ForEach(child => arguments.Add(child.Accept(this)));
return(new AndExpression(arguments));
}
/// <summary>
/// Checks the equality of objects.
/// </summary>
/// <param name="obj">Object to be checked.</param>
/// <returns>True if the objects are equal, false otherwise.</returns>
public override bool Equals(object obj)
{
AndExpression other = obj as AndExpression;
if (other == null)
{
return(false);
}
return(CollectionsEquality.Equals(Children, other.Children));
}
/// <summary>
/// Visits and transforms the expression.
/// </summary>
/// <param name="expression">Source expression.</param>
/// <returns>Transformed expression.</returns>
public override IExpression Visit(OrExpression expression)
{
List <IExpression> children = new List <IExpression>();
foreach (var child in expression.Children)
{
children.Add(child.Accept(this));
}
HashSet <IExpression> primitives = new HashSet <IExpression>();
HashSet <AndExpression> andExpressions = new HashSet <AndExpression>();
foreach (var element in children)
{
AndExpression andExpression = element as AndExpression;
if (andExpression != null)
{
andExpressions.Add(andExpression);
continue;
}
OrExpression orExpression = element as OrExpression;
if (orExpression != null)
{
foreach (var orChild in orExpression.Children)
{
primitives.Add(orChild);
}
}
else
{
// predicate, equals, numericCompare, forall, exists
primitives.Add(element);
}
}
OrExpression primitivesClause = new OrExpression(new List <IExpression>(primitives));
if (andExpressions.Count == 0)
{
return(primitivesClause);
}
List <OrExpression> clauses = new List <OrExpression>();
if (primitives.Count != 0)
{
clauses.Add(primitivesClause);
}
return(new AndExpression(DistributeDisjunctions(new List <AndExpression>(andExpressions), clauses)));
}
/// <summary>
/// Visits and performs a property count on predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <int, int> Visit(AndExpression expression)
{
int fulfilled = 0;
int notFulfilled = 0;
foreach (var child in expression.Children)
{
var childPropertyCounts = child.Accept(this);
fulfilled += childPropertyCounts.Item1;
notFulfilled += childPropertyCounts.Item2;
}
return(Tuple.Create(fulfilled, notFulfilled));
}
/// <summary>
/// Visits and transforms the expression.
/// </summary>
/// <param name="expression">Source expression.</param>
/// <returns>Transformed expression.</returns>
public override IExpression Visit(AndExpression expression)
{
List <IExpression> arguments = new List <IExpression>();
foreach (var child in expression.Children)
{
arguments.Add(child.Accept(this));
}
if (IsNegating)
{
return(new OrExpression(arguments));
}
return(new AndExpression(arguments));
}
/// <summary>
/// Visits and performs a property count on predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <double, double> Visit(AndExpression expression)
{
double positiveValue = 0.0;
double negativeValue = 0.0;
foreach (var child in expression.Children)
{
var childPropertyCounts = child.Accept(this);
if (EvaluationStrategy == ForwardCostEvaluationStrategy.ADDITIVE_VALUE)
{
positiveValue += childPropertyCounts.Item1;
negativeValue += childPropertyCounts.Item2;
}
else
{
positiveValue = Math.Max(positiveValue, childPropertyCounts.Item1);
negativeValue = Math.Max(negativeValue, childPropertyCounts.Item2);
}
}
return(Tuple.Create(positiveValue, negativeValue));
}
/// <summary>
/// Visits and transforms the expression.
/// </summary>
/// <param name="expression">Source expression.</param>
/// <returns>Transformed expression.</returns>
public override IExpression Visit(AndExpression expression)
{
HashSet <IExpression> children = new HashSet <IExpression>();
foreach (var child in expression.Children)
{
IExpression element = child.Accept(this);
AndExpression andExpr = element as AndExpression;
if (andExpr != null)
{
// unfold inner AND expression and remove duplicates
foreach (var andExprElem in andExpr.Children)
{
children.Add(andExprElem);
}
}
else
{
children.Add(element);
}
}
return(new AndExpression(new List <IExpression>(children))); // always in CNF
}
/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public override void Visit(AndExpression expression)
{
expression.Children.ForEach(child => child.Accept(this));
}
