/// <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)); }