public override IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> AssumeLessThan
(TExpr left, TExpr right, IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> env)
{
bool isBottom;
var constraints =
IntervalInference.ConstraintsFor.LessThan <IIntervalEnvironment <TVar, TExpr, TInterval, Rational>, TVar, TExpr, TInterval>
(left, right, env.Decoder, env, out isBottom);
if (isBottom)
{
return(env.Bottom);
}
var res = env;
foreach (var v in constraints.Keys)
{
var intervals = constraints[v].AsEnumerable();
foreach (var intv in intervals)
{
res = res.RefineVariable(v, intv);
}
}
return(res);
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> AssumeNotEqualToZero
(TExpr e,
IntervalEnvironmentBase
<
TVar
,
TExpr
,
TInterval
,
Rational
>
env)
{
var variable = env.Decoder.UnderlyingVariable(e);
var intv = env.Eval(e);
TInterval refinement;
if (intv.LowerBound.IsZero)
{
refinement = env.Context.For(1L, intv.UpperBound);
}
else if (intv.UpperBound.IsZero)
{
refinement = env.Context.For(intv.LowerBound, -1L);
}
else
{
refinement = env.Context.TopValue;
}
return(env.With(variable, intv.Meet(refinement)));
}
public override IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> AssumeNotEqual
(Expr left, Expr right, IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> env)
{
var result = env;
var rightIntv = env.Eval(right);
if (rightIntv.IsSinglePoint)
{
var everythingExcept = DisInterval.EverythingExcept(rightIntv);
result = result.RefineVariable(env.Decoder.UnderlyingVariable(left), everythingExcept);
}
IntervalInference.InferenceResult <Var, DisInterval> resultLeft;
IntervalInference.InferenceResult <Var, DisInterval> resultRight;
IntervalInference.ConstraintsFor.NotEqual(left, right, env.Decoder, result, out resultLeft,
out resultRight);
var join = resultLeft.Join(resultRight);
if (join.IsBottom)
{
return(env.Bottom as IntervalEnvironmentBase <Var, Expr, DisInterval, Rational>);
}
return(AssumeConstraints(join.Constraints, env));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitMultiply
(TExpr left, TExpr right, TExpr original,
IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
env = base.VisitMultiply(left, right, original, env);
return(env.Assumer.AssumeNotEqualToZero(original, env));
}
public virtual IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeEqual
(TExpr left,
TExpr right,
IntervalEnvironmentBase
<TVar,
TExpr,
TInterval,
TNumeric>
env)
{
var leftVar = env.Decoder.UnderlyingVariable(left);
var rightVar = env.Decoder.UnderlyingVariable(right);
if (env.Contains(leftVar))
{
var res = env;
var interval = env.Eval(left).Meet(env.Eval(right));
res = res.With(leftVar, interval);
res = res.With(rightVar, interval);
return(res);
}
if (env.Decoder.IsConstant(left) && env.Decoder.IsConstant(right) &&
env.Eval(left).Meet(env.Eval(right)).IsBottom)
{
return(env.Bottom);
}
return(env);
}
protected override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> DispatchCompare(
CompareVisitor cmp, TExpr left, TExpr right, TExpr original,
IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> data)
{
data = cmp(left, right, original, data);
return(base.DispatchCompare(cmp, left, right, original, data));
}
public abstract IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeLessThan
(TExpr left,
TExpr right,
IntervalEnvironmentBase
<TVar,
TExpr,
TInterval
,
TNumeric
> env);
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> AssumeGreaterEqualThanZero
(TExpr expr,
IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> env)
{
var constraints =
IntervalInference.ConstraintsFor.GreaterEqualThanZero
<IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational>, TVar, TExpr, TInterval>
(expr, env.Decoder, env);
return(AssumeConstraints(constraints, env));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> AssumeLessEqualThan
(
TInterval intv, TVar right, IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> env)
{
TInterval refined;
if (
!IntervalInference.ConstraintsFor.TryRefineLessEqualThan
<IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational>, TVar, TExpr, TInterval>
(intv, right, env, out refined))
{
return(env);
}
return(env.With(right, refined));
}
public override IntervalEnvironmentBase <TVar, TExpr, Interval, Rational> AssumeNotEqual
(TExpr left, TExpr right, IntervalEnvironmentBase <TVar, TExpr, Interval, Rational> env)
{
IntervalInference.InferenceResult <TVar, Interval> resultLeft;
IntervalInference.InferenceResult <TVar, Interval> resultRight;
IntervalInference.ConstraintsFor.NotEqual(left, right, env.Decoder, env, out resultLeft,
out resultRight);
IntervalInference.InferenceResult <TVar, Interval> join = resultLeft.Join(resultRight);
if (join.IsBottom)
{
return(env.Bottom);
}
return(this.AssumeConstraints(join.Constraints, env));
}
public virtual IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeEqualToZero
(TVar var,
IntervalEnvironmentBase
<
TVar
,
TExpr
,
TInterval
,
TNumeric
>
env)
{
return(env.RefineVariable(var, env.Context.Zero));
}
protected IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeConstraints
(IImmutableMap <TVar, Sequence <TInterval> > constraints,
IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
var res = env;
foreach (var v in constraints.Keys)
{
var seq = constraints[v];
foreach (var intv in seq.AsEnumerable())
{
res = res.RefineVariable(v, intv);
}
}
return(res);
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> AssumeLessEqualThan
(TExpr left, TExpr right, IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational> env)
{
bool isBottom;
var constraints =
IntervalInference.ConstraintsFor.LessEqualThan
<IntervalEnvironmentBase <TVar, TExpr, TInterval, Rational>, TVar, TExpr, TInterval>
(left, right, env.Decoder, env,
out isBottom);
if (isBottom)
{
return(env.Bottom);
}
return(AssumeConstraints(constraints, env));
}
public virtual IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeNotEqual
(TExpr left,
TExpr right,
IntervalEnvironmentBase
<TVar,
TExpr,
TInterval
,
TNumeric
> env)
{
int value;
if (env.Decoder.OperatorFor(left).IsRelational() && env.Decoder.IsConstantInt(right, out value))
{
return(value == 0 ? env.AssumeTrue(left) : env.AssumeFalse(left));
}
var assumer = env.Assumer;
return(assumer.AssumeLessThan(left, right, env).Join(assumer.AssumeLessThan(right, left, env)));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitLessEqualThan
(TExpr left, TExpr right, TExpr original,
IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
return(env.Assumer.AssumeLessEqualThan(left, right, env));
}
public abstract IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeGreaterEqualThanZero
(TExpr expr, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env);
public abstract IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeLessEqualThan
(TInterval intv, TVar right, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env);
public abstract IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> AssumeNotEqualToZero
(TExpr e, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env);
public bool LessEqual(IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> that)
{
return(vars_to_intervals.LessEqual(that.vars_to_intervals));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> Visit(TExpr expr,
IntervalEnvironmentBase
<TVar, TExpr,
TInterval,
TNumeric> data)
{
var res = base.Visit(expr, data);
if (!Decoder.IsBinaryExpression(expr))
{
return(res);
}
var left = Decoder.LeftExpressionFor(expr);
var right = Decoder.RightExpressionFor(expr);
var intv = data.Eval(right);
if (intv.IsBottom)
{
return(data.Bottom);
}
if (!intv.IsSinglePoint)
{
return(res);
}
switch (Decoder.OperatorFor(expr))
{
case ExpressionOperator.LessThan: {
var leftVar = Decoder.UnderlyingVariable(left);
return(res.Assumer.AssumeLessEqualThan(intv, leftVar, res));
}
case ExpressionOperator.LessEqualThan: {
var leftVar = Decoder.UnderlyingVariable(left);
return(res.Assumer.AssumeLessThan(intv, leftVar, res));
}
}
return(data);
}
static IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> AssumeEqualToDisInterval
(Var var, DisInterval intv, IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> env)
{
return(env.RefineVariable(var, intv));
}
public override IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> AssumeNotEqualToZero
(Var var, IntervalEnvironmentBase <Var, Expr, DisInterval, Rational> env)
{
return(AssumeEqualToDisInterval(var, DisInterval.NotZero, env));
}
public override IntervalEnvironmentBase <TVar, TExpr, Interval, Rational> AssumeNotEqualToZero
(TVar v, IntervalEnvironmentBase <TVar, TExpr, Interval, Rational> env)
{
//do nothing, we can't exclude one point
return(env);
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitVariable
(TVar var, TExpr expr, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
return(env.Assumer.AssumeNotEqualToZero(expr, env));
}
public IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> Meet(IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> that)
{
return(NewInstance(vars_to_intervals.Meet(that.vars_to_intervals)));
}
public IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> Join(IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> that, bool widen, out bool weaker)
{
return(NewInstance(vars_to_intervals.Join(that.vars_to_intervals, widen, out weaker)));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitUnknown
(TExpr expr, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
env = base.VisitUnknown(expr, env);
return(env.Assumer.AssumeNotEqualToZero(expr, env));
}
public override IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitNot
(TExpr expr, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> env)
{
return(FalseVisitor.Visit(expr, env));
}
public IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> VisitFalse(TExpr guard, IntervalEnvironmentBase <TVar, TExpr, TInterval, TNumeric> data)
{
return(false_visitor.Visit(guard, data));
}