public void VisitBooleanAndExpr(bool a, bool b, ValueType expected)
{
var target = new TypeCheckingVisitor();
var aExpression = new ConstantExpr(a);
var bExpression = new ConstantExpr(b);
var expr = new AndExpr(aExpression, bExpression);
var actual = target.Visit(expr, scope);
Assert.AreEqual(expected, actual);
}
public void AndOrTest()
{
var target = new TypeCheckingVisitor();
var expr = new AndExpr(new ConstantExpr(true), new OrExpr(new ConstantExpr(true), new ConstantExpr(false)));
var actual = target.Visit(expr, scope);
Assert.AreEqual(ValueType.Boolean, actual);
}
public void VisitBooleanAndExpr(object a, object b, string expected)
{
var target = new PrintVisitor();
var aExpression = new ConstantExpr(a);
var bExpression = new ConstantExpr(b);
var expr = new AndExpr(aExpression, bExpression);
var actual = target.Visit(expr, scope);
Assert.AreEqual(expected, actual);
}
protected IType CheckExpr(AndExpr expr)
{
IType a = CheckExpr(expr.Expr1);
IType b = CheckExpr(expr.Expr2);
if (!(a is BoolType) || !a.CompatibleWith(b))
{
AddError(String.Format("'&&' not possible. Incompatible types: '{0}', '{1}'. Only the bool type is supported.",
a.ToString(), b.ToString()), true, expr.SourcePosition);
}
return BoolType.Instance;
}
public ValueType Visit(AndExpr expr, Scope scope)
{
return(BinaryOperatorTypeCheck(expr, scope));
}
// Requires condition to be atomic
private void CacheNormalizedImplication(
DomainTermExpr condition, DomainBoolExpr implies)
{
// Check that we do not have a rule with an inconsistent condition yet
// such rules cannot be accommodated: we require rule premises to be pair wise
// variable disjoint (note that the rules with coinciding conditions are merged)
// rules with inconsistent conditions may make the chase incomplete:
// For instance, consider the KB {c->a, b->c, !b->a} and the condition "!a".
// chase(!a, KB) = !a, but !a ^ KB is unsatisfiable.
foreach (var premise in Implications.Keys)
{
if (premise.Identifier.Variable.Equals(condition.Identifier.Variable)
&&
!premise.Identifier.Range.SetEquals(condition.Identifier.Range))
{
CacheResidualFact(new OrExpr <DomainConstraint>(new NotExpr <DomainConstraint>(condition), implies));
return;
}
}
// We first chase the implication with all the existing facts, and then
// chase implications of all existing rules, and all residual facts with the
// resulting enhanced rule
var dnfImpl = new Converter <DomainConstraint>(
Chase(implies),
IdentifierService <DomainConstraint> .Instance.CreateConversionContext()).Dnf.Expr;
// Now chase all our knowledge with the rule "condition => dnfImpl"
// Construct a fake knowledge base for this sake
var kb = new FragmentQueryKBChaseSupport();
kb.Implications[condition] = dnfImpl;
var newKey = true;
foreach (var key in new Set <TermExpr <DomainConstraint> >(Implications.Keys))
{
var chasedRuleImpl = kb.Chase(Implications[key]);
if (key.Equals(condition))
{
newKey = false;
chasedRuleImpl = new AndExpr <DomainConstraint>(chasedRuleImpl, dnfImpl);
}
// Simplify using the solver
Implications[key] = new Converter <DomainConstraint>(
chasedRuleImpl,
IdentifierService <DomainConstraint> .Instance.CreateConversionContext()).Dnf.Expr;
}
if (newKey)
{
Implications[condition] = dnfImpl;
}
// Invalidate residue
_residueSize = -1;
}
public void AndOrTest()
{
var target = new EvaluateVisitor();
var expr = new AndExpr(new ConstantExpr(true), new OrExpr(new ConstantExpr(true), new ConstantExpr(false)));
var actual = target.Visit(expr, _scope);
Assert.AreEqual(true, actual.ToBoolean());
}
public void VisitBooleanAndExpr(bool a, bool b, bool expected)
{
var target = new EvaluateVisitor();
var aExpression = new ConstantExpr(a);
var bExpression = new ConstantExpr(b);
var expr = new AndExpr(aExpression, bExpression);
var actual = target.Visit(expr, _scope);
Assert.AreEqual(expected, actual.ToBoolean());
}
internal abstract T_Return VisitAnd(AndExpr <T_Identifier> expression);
internal override DomainBoolExpr VisitAnd(AndExpr <DomainConstraint> expression)
{
return(new OrExpr <DomainConstraint>(expression.Children.Select(child => child.Accept(this))));
}
/// <param name="andex">
/// is the 'and' expression. </param>
/// <returns> make logic expr(andex). </returns>
public virtual object visit(AndExpr andex)
{
return(make_logic_expr(andex));
}
