public void RequiresXMinusOne()
{
Init();
bool hitExpectedBreakPoint = false;
e.BreakPointReached += delegate(object executor, Executor.BreakPointEventArgs data)
{
if (data.Name != "cmodset")
{
return;
}
hitExpectedBreakPoint = true;
// Check for "requires x > -1" constraint
var xTuple = e.CurrentState.GetInScopeVariableAndExprByName("x");
var xVar = xTuple.Key;
// Find the symbolic associated with this variable
// FIXME: Broken
//var symbolicForX = e.CurrentState.Symbolics.Where( s => s.Origin.IsVariable && s.Origin.AsVariable == xVar).First();
SymbolicVariable symbolicForX = null; // Just so it compiles
// FIXME: Move constant construction functions to utility so can be shared across tests.
var expectedConstraint = Expr.Gt(symbolicForX.Expr, Expr.Neg(Builder.ConstantInt(1)));
int hasConstraint = e.CurrentState.Constraints.Constraints.Where(c => c.Condition.Equals(expectedConstraint)).Count();
Assert.AreEqual(1, hasConstraint);
};
e.Run(GetMain(p));
Assert.IsTrue(hitExpectedBreakPoint);
}
public void Arguments()
{
var tcDecl = new TypeCtorDecl(Token.NoToken, "fox", 1);
var tc = new CtorType(Token.NoToken, tcDecl, new List <Microsoft.Boogie.Type>()
{
Microsoft.Boogie.Type.Bool
});
var tcTypeIdent = new TypedIdent(Token.NoToken, "fox", tc);
var gv = new GlobalVariable(Token.NoToken, tcTypeIdent);
// FIXME: The Symbolic constructor shouldn't really need the program location
gv.SetMetadata <ProgramLocation>((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(gv));
var sym = new SymbolicVariable("y", gv);
var builder = new SimpleExprBuilder(/*immutable=*/ true);
var eq = builder.Eq(sym.Expr, sym.Expr);
Assert.IsNotInstanceOf <LiteralExpr>(eq); // Check that it wasn't constant folded
using (var writer = new StringWriter())
{
var printer = GetPrinter(writer);
printer.AddDeclarations(eq);
printer.PrintSortDeclarations();
Assert.AreEqual("(declare-sort @fox)\n", writer.ToString());
}
}
private void EvaluateButton_Click(object sender, RoutedEventArgs e)
{
CurrentExpression = SymbolicVariable.Parse(ExpressionTextBox.Text);
ExpressionResult.Text = CurrentExpression.ToString();
D3Chart.Title = CurrentExpression.ToString();
ParametersPanel.Children.Clear();
// create dynamic sliders for the expression.
foreach (var p in CurrentExpression.InvolvedSymbols)
{
Slider s = new Slider()
{
Name = p + "Slider", Tag = p
};
s.Minimum = double.Parse(MinimumTextBox.Text);
s.Maximum = double.Parse(MaximumTextBox.Text);
s.Value = s.Minimum;
s.ValueChanged += new RoutedPropertyChangedEventHandler <double>(Sliders_ValueChanged);
ParametersPanel.Children.Add(new TextBlock {
Text = p
});
ParametersPanel.Children.Add(s);
}
lgraph.Points.Clear();
}
public void ShouldBeSame()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var id = builder.Identifier(v);
var c0 = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c0Copy = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c1 = new Constraint(builder.Lt(id, builder.ConstantInt(10)));
var c1Copy = new Constraint(builder.Lt(id, builder.ConstantInt(10)));
var CM0 = new ConstraintManager();
Assert.AreEqual(0, CM0.GetHashCode());
CM0.AddConstraint(c0);
var firstHashCode = CM0.GetHashCode();
CM0.AddConstraint(c1);
Assert.AreNotEqual(firstHashCode, CM0.GetHashCode());
var CM1 = new ConstraintManager();
CM1.AddConstraint(c0Copy);
Assert.AreEqual(firstHashCode, CM1.GetHashCode());
CM1.AddConstraint(c1Copy);
Assert.AreEqual(CM0.GetHashCode(), CM1.GetHashCode());
Assert.IsTrue(CM0.Equals(CM1));
}
private void CheckType(Microsoft.Boogie.Type type, LiteralExpr theConstant, string expectedType, string expectedExpr)
{
string result = null;
using (var stringWriter = new StringWriter())
{
var printer = GetPrinter(stringWriter);
var ts = CreateTypeSynonym(type, "mysn");
// Check we get the basic type back
Assert.AreEqual(expectedType, SMTLIBQueryPrinter.GetSMTLIBType(ts));
// Now check it can be used in a query
var typeIdent = new TypedIdent(Token.NoToken, "thetype", ts);
var variable = new LocalVariable(Token.NoToken, typeIdent);
// SymbolicVariable constructor requires that a ProgramLocation is already attached
variable.SetMetadata((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(variable));
var symbolic = new SymbolicVariable("symbolic_0", variable);
var theExpr = Expr.Eq(symbolic.Expr, theConstant);
printer.AddDeclarations(theExpr);
printer.PrintExpr(theExpr);
result = stringWriter.ToString();
}
Assert.AreEqual(expectedExpr, result);
}
public void GetSubSet()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var id = builder.Identifier(v);
var c0 = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c1 = new Constraint(builder.Lt(id, builder.ConstantInt(10)));
var CM0 = new ConstraintManager();
var CMSubset = new ConstraintManager();
CM0.AddConstraint(c0);
CM0.AddConstraint(c1);
CMSubset.AddConstraint(c1);
var getSubset = CM0.GetSubSet(new HashSet <Constraint>()
{
c1
});
// Check they are the same
Assert.AreEqual(1, getSubset.Count);
Assert.AreEqual(1, CMSubset.Count);
Assert.AreEqual(CMSubset.GetHashCode(), getSubset.GetHashCode());
Assert.IsTrue(CMSubset.Equals(getSubset));
}
public void DoClone()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var id = builder.Identifier(v);
var c0 = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c1 = new Constraint(builder.Lt(id, builder.ConstantInt(10)));
var CM0 = new ConstraintManager();
CM0.AddConstraint(c0);
CM0.AddConstraint(c1);
var copy = CM0.Clone();
Assert.AreNotSame(CM0, copy);
Assert.AreEqual(CM0.Count, copy.Count);
Assert.AreEqual(CM0.GetHashCode(), copy.GetHashCode());
Assert.IsTrue(CM0.Equals(copy));
// Modify original and check copy has not changed
CM0.AddConstraint(new Constraint(builder.Lt(id, builder.ConstantInt(8))));
Assert.AreNotEqual(copy.GetHashCode(), CM0.GetHashCode());
Assert.IsFalse(CM0.Equals(copy));
Assert.AreEqual(2, copy.Count);
Assert.AreEqual(3, CM0.Count);
}
public void ConstraintDifferent()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var id = builder.Identifier(v);
var c0 = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c0Copy = new Constraint(builder.Gt(id, builder.ConstantInt(0)));
var c1 = new Constraint(builder.Lt(id, builder.ConstantInt(10)));
var c1diff = new Constraint(builder.Le(id, builder.ConstantInt(10)));
var CM0 = new ConstraintManager();
var CM1 = new ConstraintManager();
CM0.AddConstraint(c0);
CM0.AddConstraint(c1);
CM1.AddConstraint(c0Copy);
CM1.AddConstraint(c1diff);
var queryExpr0 = builder.Eq(id, builder.ConstantInt(5));
var queryExpr1 = builder.Eq(id, builder.ConstantInt(5));
var query0 = new Symbooglix.Solver.Query(CM0, new Constraint(queryExpr0));
var query1 = new Symbooglix.Solver.Query(CM1, new Constraint(queryExpr1));
Assert.AreNotEqual(query0.GetHashCode(), query1.GetHashCode());
Assert.IsFalse(query0.Equals(query1));
}
public void ShouldBeIdentical()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var c0 = new Constraint(builder.Lt(builder.Identifier(v), builder.ConstantInt(5)));
var c1 = new Constraint(builder.Lt(builder.Identifier(v), builder.ConstantInt(5)));
Assert.AreEqual(c0.GetHashCode(), c1.GetHashCode());
Assert.IsTrue(c0.Equals(c1));
// Check used variables
Assert.AreEqual(1, c0.UsedVariables.Count);
Assert.AreEqual(1, c1.UsedVariables.Count);
Assert.IsTrue(c0.UsedVariables.Contains(v));
Assert.IsTrue(c1.UsedVariables.Contains(v));
Assert.AreEqual(0, c0.UsedUninterpretedFunctions.Count);
Assert.AreEqual(0, c1.UsedUninterpretedFunctions.Count);
}
/// <summary>
/// Returns Quantity of the symbolic variable based on the unit
/// </summary>
/// <param name="sv"></param>
/// <param name="unit"></param>
/// <returns></returns>
public static AnyQuantity <SymbolicVariable> ToQuantity(this SymbolicVariable sv, string unit = "1")
{
Unit sunit = Unit.Parse(unit);
AnyQuantity <SymbolicVariable> SymbolicQuantity = sunit.GetThisUnitQuantity <SymbolicVariable>(sv);
return(SymbolicQuantity);
}
/// <summary>
/// \/ * value operation is called gradient
/// gradient over scalar field generate a vector
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public override QsValue MultiplyOperation(QsValue value)
{
var fscalar = value as QsScalar;
if (!Object.ReferenceEquals(fscalar, null))
{
// Here we will multiply the nabla \/ * with @function
if (!Object.ReferenceEquals(fscalar.FunctionQuantity, null))
{
var f = fscalar.FunctionQuantity.Value;
string[] prms = f.ParametersNames;
SymbolicVariable fsv = f.ToSymbolicVariable();
QsVector GradientResult = new QsVector();
// we loop through the symbolic body and differentiate it with respect to the function parameters.
// then accumulate the
foreach (string prm in prms)
{
GradientResult.AddComponent(fsv.Differentiate(prm).ToQuantity().ToScalar());
}
return(GradientResult);
}
}
if (value is QsVector)
{
return(this.DelVector.MultiplyVector((QsVector)value));
}
throw new NotImplementedException(@"Multiplication of \/ * " + value.GetType().Name + " Not implemented yet");
}
/// <summary>
/// Returns the function body as symbolic quantity scalar.
/// </summary>
public QsScalar ToSymbolicScalar()
{
//return (QsScalar)QsEvaluator.CurrentEvaluator.SilentEvaluate(SymbolicBodyText);
var fv = SymbolicVariable.Parse(this.FunctionBody);
return(new QsScalar(ScalarTypes.SymbolicQuantity)
{
SymbolicQuantity = fv.ToQuantity()
});
}
public void SolveTest()
{
var ss = SymbolicVariable.Parse("3*x-4");
Assert.AreEqual(4.0 / 3, ss.Solve());
var r = SymbolicVariable.Parse("5-3*x");
Assert.AreEqual(5.0 / 3.0, r.Solve());
}
/// <summary>
/// Differentiate operation for function.
/// </summary>
/// <param name="value">object of <see cref="QsScalar"/> that hold <see cref="AnyQuantity<SymbolicVariable>"/></param>
/// <returns></returns>
public override QsValue DifferentiateOperation(QsValue value)
{
QsScalar sval = (QsScalar)value;
if (sval.ScalarType == ScalarTypes.SymbolicQuantity)
{
var dsv = sval.SymbolicQuantity.Value;
string fname = "_";
string WholeFunction = string.Empty;
if (this.FunctionBodyToken[0].TokenClassType == typeof(CurlyBracketGroupToken))
{
// vector differentiation
// take every term in the vector and differentiate it
var vcs = QsVar.VectorComponents(this.FunctionBodyToken[0]);
StringBuilder sc = new StringBuilder();
sc.Append(fname + "(" + RemoveRedundantParameters(this.ParametersNames) + ") = ");
sc.Append("{ ");
foreach (var c in vcs)
{
SymbolicVariable nsv = SymbolicVariable.Parse(c);
int times = (int)dsv.SymbolPower;
while (times > 0)
{
nsv = nsv.Differentiate(dsv.Symbol);
times--;
}
sc.Append(nsv.ToString());
sc.Append(" ");
}
sc.Append("}");
WholeFunction = sc.ToString();
}
else
{
SymbolicVariable nsv = ToSymbolicVariable();
int times = (int)dsv.SymbolPower;
while (times > 0)
{
nsv = nsv.Differentiate(dsv.Symbol);
times--;
}
WholeFunction = fname + "(" + RemoveRedundantParameters(this.ParametersNames) + ") = " + nsv.ToString();
}
return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction));
}
else
{
return(base.DifferentiateOperation(value));
}
}
public void RemoveNoConstraintsBasedOnVars()
{
IConstraintManager CM = new ConstraintManager();
IExprBuilder builder = GetBuilder();
// Dummy Boogie variable
var bv8TypeIdent = new TypedIdent(Token.NoToken, "bv8", Microsoft.Boogie.Type.GetBvType(8));
var dummyVarBv = new GlobalVariable(Token.NoToken, bv8TypeIdent);
// dummyVar needs a programLocation, otherwise SymbolicVariable constructor raises an exception
var progLoc = new ProgramLocation(dummyVarBv);
dummyVarBv.SetMetadata <ProgramLocation>((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, progLoc);
var s0 = new SymbolicVariable("s0", dummyVarBv).Expr;
var s1 = new SymbolicVariable("s1", dummyVarBv).Expr;
var s2 = new SymbolicVariable("s2", dummyVarBv).Expr;
// Construct some constraints
Expr c0 = builder.Eq(builder.BVAND(s0, s1), builder.ConstantBV(0, 8));
Expr c1 = builder.Eq(s2, builder.ConstantBV(1, 8));
CM.AddConstraint(c0, progLoc);
CM.AddConstraint(c1, progLoc);
var mockSolver = new MockSolver();
var indepenceSolver = new Symbooglix.Solver.ConstraintIndependenceSolver(mockSolver);
Expr queryExpr = builder.Eq(builder.BVAND(s1, s2), builder.ConstantBV(0, 8));
indepenceSolver.ComputeSatisfiability(new Solver.Query(CM, new Constraint(queryExpr)));
// Check no constraints were removed
Assert.AreEqual(2, mockSolver.Constraints.Count);
Assert.AreSame(queryExpr, mockSolver.QueryExpr);
bool c0Found = false;
bool c1Found = false;
foreach (var constraint in mockSolver.Constraints)
{
if (c0 == constraint.Condition)
{
c0Found = true;
}
if (c1 == constraint.Condition)
{
c1Found = true;
}
}
Assert.IsTrue(c0Found);
Assert.IsTrue(c1Found);
}
public void SolveVariableTest()
{
var h = SymbolicVariable.Parse("2*x+4*y-4");
var hs = h.Solve("x");
Assert.AreEqual("-2*y+2", hs.ToString());
var v = SymbolicVariable.Parse("5*u-4/r+3*h-2*x");
Assert.AreEqual("2.5*u-2/r+1.5*h", v.Solve("x").ToString());
Assert.AreEqual("-1.66666666666667*u+1.33333333333333/r+0.666666666666667*x", v.Solve("h").ToString());
}
public void ShouldNotBeIdentical()
{
var builder = new SimpleExprBuilder(true);
var dummyV = SymbooglixLibTests.MapProxyTests.GetVariable("dummy", BPLType.Int);
// Hack
dummyV.SetMetadata((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(dummyV));
var v = new SymbolicVariable("foo", dummyV);
var c0 = new Constraint(builder.Lt(builder.Identifier(v), builder.ConstantInt(5)));
var c1 = new Constraint(builder.Gt(builder.Identifier(v), builder.ConstantInt(5)));
Assert.AreNotEqual(c0.GetHashCode(), c1.GetHashCode());
Assert.IsFalse(c0.Equals(c1));
}
public void MapWithTypeConstructorTypesNoArguments()
{
var tcDecl = new TypeCtorDecl(Token.NoToken, "fox", 0);
var tc = new CtorType(Token.NoToken, tcDecl, new List <Microsoft.Boogie.Type>());
var tcDecl2 = new TypeCtorDecl(Token.NoToken, "fox_two", 0);
var tc2 = new CtorType(Token.NoToken, tcDecl2, new List <Microsoft.Boogie.Type>());
var tcDecl3 = new TypeCtorDecl(Token.NoToken, "fox_three", 0);
var tc3 = new CtorType(Token.NoToken, tcDecl3, new List <Microsoft.Boogie.Type>());
var mapType = new MapType(
Token.NoToken,
new List <Microsoft.Boogie.TypeVariable>(),
new List <Microsoft.Boogie.Type>()
{
tc, tc2
},
tc3);
var mapTypeTypeIdent = new TypedIdent(Token.NoToken, "mapx", mapType);
var gv = new GlobalVariable(Token.NoToken, mapTypeTypeIdent);
// FIXME: The Symbolic constructor shouldn't really need the program location
gv.SetMetadata <ProgramLocation>((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(gv));
var sym = new SymbolicVariable("y", gv);
var builder = new SimpleExprBuilder(/*immutable=*/ true);
var eq = builder.Eq(sym.Expr, sym.Expr);
Assert.IsNotInstanceOf <LiteralExpr>(eq); // Check that it wasn't constant folded
using (var writer = new StringWriter()) {
var printer = GetPrinter(writer);
printer.AddDeclarations(eq);
printer.PrintSortDeclarations();
var str = writer.ToString().Trim();
// Check we can see all the sort declarations we expect but don't depend on their order
Assert.IsTrue(str.Contains("(declare-sort @fox)"));
Assert.IsTrue(str.Contains("(declare-sort @fox_two)"));
Assert.IsTrue(str.Contains("(declare-sort @fox_three)"));
}
}
public Microsoft.Boogie.LiteralExpr GetAssignment(SymbolicVariable SV)
{
if (SV.TypedIdent.Type.IsBv)
{
int width = SV.TypedIdent.Type.BvBits;
return(new LiteralExpr(Token.NoToken, BigNum.FromInt(defaultValue), width));
}
else if (SV.TypedIdent.Type.IsBool)
{
return(defaultValue > 0 ? Expr.True : Expr.False);
}
else if (SV.TypedIdent.Type.IsInt)
{
return(new LiteralExpr(Token.NoToken, BigNum.FromInt(defaultValue)));
}
else if (SV.TypedIdent.Type.IsReal)
{
return(new LiteralExpr(Token.NoToken, BigDec.FromInt(defaultValue)));
}
else
{
throw new NotImplementedException();
}
}
protected SymbolicVariable read([CallerMemberName] string PropertyName = null) => PropertyValues.TryFind(PropertyName).ValueOrElse(() => SymbolicVariable.Define(PropertyName));
public Curve(SymbolicVariable x, SymbolicVariable y, SymbolicVariable z)
{
fx = x;
fy = y;
fz = z;
}
protected override string FormatMember(SymbolicVariable member)
=> $"{tab()}<{member.VariableName}>{member.Format()}</{member.VariableName}>";
protected void write(SymbolicVariable Value, [CallerMemberName] string PropertyName = null) => PropertyValues[PropertyName] = SymbolicVariable.Define(PropertyName, Value.Components.ToArray());
public static Curve GetCurve(SymbolicVariable x, SymbolicVariable y, SymbolicVariable z)
{
return(new Curve(x, y, z));
}
public EmbeddedResource(ISymbolicExpression Include, SymbolicVariable LogicalName, string Label, string Condition = null)
: base(nameof(EmbeddedResource), Include, Label, Condition)
{
this.LogicalName = LogicalName;
}
public AnyQuantity <SymbolicVariable> ToSymbolicQuantity()
{
var fv = SymbolicVariable.Parse(this.FunctionBody);
return(fv.ToQuantity());
}
public SymbolicVariable ToSymbolicVariable()
{
return(SymbolicVariable.Parse(this.FunctionBody));
}
/// <summary>
/// Take the value and operation in text and return the current function operationed by value.
/// </summary>
/// <param name="value"></param>
/// <param name="operation"></param>
/// <returns></returns>
private QsFunction FOperation(QsValue value, string operation)
{
if (value is QsFunction)
{
QsFunction fn2 = (QsFunction)value;
string fParameters = RemoveRedundantParameters(this.ParametersNames.Union(fn2.ParametersNames).ToArray());
string thisFunctionBody = this.FunctionBody;
foreach (string p in this.ParametersNames)
{
thisFunctionBody = thisFunctionBody.Replace(p, "$" + p);
}
string targetFunctionBody = fn2.FunctionBody;
foreach (string p in fn2.ParametersNames)
{
targetFunctionBody = targetFunctionBody.Replace(p, "$" + p);
}
// form the expressions that will be parsed.
string fpt = "(" + thisFunctionBody + ")" + operation + "(" + targetFunctionBody + ")";
fpt = fpt.Replace("!", "__FAC__"); // replacing the ! sign with __FAC__ to include the '!' sign into the calculations {because '!' is operator in parsing so it doesn't enter the algebraic calculations}
//evaulate fpt
try
{
QsScalar sc = (QsScalar)QsEvaluator.CurrentEvaluator.SilentEvaluate(fpt);
string FuncBody = sc.SymbolicQuantity.Value.ToString().Replace("__FAC__", "!");
string WholeFunction = "_(" + fParameters + ") = " + FuncBody;
return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction));
}
catch (QsIncompleteExpression)
{
// something happened make the operation in old fashion
string WholeFunction;
Token FunctionToken = JoinFunctionsArrayTokensWithOperation(operation, out WholeFunction, this, fn2);
return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction, FunctionToken));
}
}
else if (value is QsScalar)
{
QsScalar svl = (QsScalar)value;
var fname = "_";
var fbody = this.FunctionBody;
if (svl.ScalarType == ScalarTypes.SymbolicQuantity)
{
fbody = "(" + fbody + ")" + operation + "(" + svl.SymbolicQuantity.Value.ToString() + ")";
}
else if (svl.ScalarType == ScalarTypes.NumericalQuantity)
{
fbody = "(" + fbody + ")" + operation + svl.NumericalQuantity.Value.ToString();
}
else if (svl.ScalarType == ScalarTypes.RationalNumberQuantity)
{
fbody = "(" + fbody + ")" + operation + svl.RationalQuantity.Value.Value.ToString();
}
else if (svl.ScalarType == ScalarTypes.FunctionQuantity)
{
fbody = "(" + fbody + ")" + operation + "(" + svl.FunctionQuantity.Value.FunctionBody + ")";
}
else
{
throw new QsException("Operation '" + operation + "' for the target scalar type (" + svl.ScalarType + ") is not supported");
}
QsScalar fb = SymbolicVariable.Parse(fbody).ToQuantity().ToScalar();
string FuncBody = string.Empty;
if (fb.ScalarType == ScalarTypes.SymbolicQuantity)
{
FuncBody = fb.SymbolicQuantity.Value.ToString().Replace("__FAC__", "!");
}
else
{
FuncBody = fb.ToExpressionParsableString();
}
string[] functionParametersArray = this.ParametersNames; // this is the available parameters for the original function.
if (svl.ScalarType == ScalarTypes.SymbolicQuantity)
{
List <string> newParametersList = new List <string>(functionParametersArray);
newParametersList.AddRange(svl.SymbolicQuantity.Value.InvolvedSymbols);
functionParametersArray = newParametersList.ToArray();
}
if (svl.ScalarType == ScalarTypes.FunctionQuantity)
{
List <string> newParametersList = new List <string>(functionParametersArray);
newParametersList.AddRange(svl.FunctionQuantity.Value.ParametersNames);
functionParametersArray = newParametersList.ToArray();
}
var f = fname + "(" + RemoveRedundantParameters(functionParametersArray) + ") = " + FuncBody;
return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, f));
}
else
{
throw new NotImplementedException();
}
}
private void SimpleLoop(IStateScheduler scheduler)
{
p = LoadProgramFrom("programs/SimpleLoop.bpl");
e = GetExecutor(p, scheduler, GetSolver(), /*useConstantFolding=*/ true);
var main = p.TopLevelDeclarations.OfType <Implementation>().Where(i => i.Name == "main").First();
var boundsVar = main.InParams[0];
var entryBlock = main.Blocks[0];
Assert.AreEqual("entry", entryBlock.Label);
var loopHead = main.Blocks[1];
Assert.AreEqual("loopHead", loopHead.Label);
var loopBody = main.Blocks[2];
Assert.AreEqual("loopBody", loopBody.Label);
var loopBodyAssume = loopBody.Cmds[0] as AssumeCmd;
Assert.IsNotNull(loopBodyAssume);
var loopExit = main.Blocks[3];
Assert.AreEqual("loopDone", loopExit.Label);
var loopExitAssume = loopExit.Cmds[0] as AssumeCmd;
Assert.IsNotNull(loopExitAssume);
var exitBlock = main.Blocks[4];
Assert.AreEqual("exit", exitBlock.Label);
var tc = new TerminationCounter();
tc.Connect(e);
int change = 1;
int contextChangeCount = 0;
e.ContextChanged += delegate(object sender, Executor.ContextChangeEventArgs eventArgs)
{
++contextChangeCount;
// FIXME:
//var symbolicForBound = eventArgs.Previous.Symbolics.Where( s => s.Origin.IsVariable && s.Origin.AsVariable == boundsVar).First();
SymbolicVariable symbolicForBound = null; // Just so we can compile
if (change == 1)
{
// FIXME: The Executor shouldn't pop the last stack frame so we can check where we terminated successfully
Assert.IsTrue(eventArgs.Previous.TerminationType.ExitLocation.IsTransferCmd);
Assert.IsTrue(eventArgs.Previous.TerminationType.ExitLocation.AsTransferCmd is ReturnCmd);
Assert.IsTrue(eventArgs.Previous.Finished());
Assert.AreEqual(3, eventArgs.Previous.Constraints.Count);
var exitConstraint = eventArgs.Previous.Constraints.Constraints.Where(c => c.Origin.IsCmd && c.Origin.AsCmd == loopExitAssume);
Assert.AreEqual(1, exitConstraint.Count());
Assert.AreEqual(symbolicForBound.Name + " <= 0", exitConstraint.First().Condition.ToString());
Assert.AreSame(loopBody, eventArgs.Next.GetCurrentBlock());
Assert.AreEqual(2, eventArgs.Next.Constraints.Count);
var bodyConstraint = eventArgs.Next.Constraints.Constraints.Where(c => c.Origin.IsCmd && c.Origin.AsCmd == loopBodyAssume);
Assert.AreEqual(1, bodyConstraint.Count());
Assert.AreEqual("0 < " + symbolicForBound.Name, bodyConstraint.First().Condition.ToString());
}
else if (change == 2)
{
Assert.IsTrue(eventArgs.Previous.Finished());
Assert.AreSame(loopBody, eventArgs.Next.GetCurrentBlock());
Assert.AreEqual(4, eventArgs.Previous.Constraints.Count);
var exitConstraint = eventArgs.Previous.Constraints.Constraints.Where(c => c.Origin.IsCmd && c.Origin.AsCmd == loopExitAssume);
Assert.AreEqual(1, exitConstraint.Count());
Assert.AreEqual(symbolicForBound.Name + " <= 1", exitConstraint.First().Condition.ToString());
Assert.AreSame(loopBody, eventArgs.Next.GetCurrentBlock());
Assert.AreEqual(3, eventArgs.Next.Constraints.Count);
var bodyConstraints = eventArgs.Next.Constraints.Constraints.Where(c => c.Origin.IsCmd && c.Origin.AsCmd == loopBodyAssume).ToList();
Assert.AreEqual(2, bodyConstraints.Count());
Assert.AreEqual("0 < " + symbolicForBound.Name, bodyConstraints[0].Condition.ToString());
Assert.AreEqual("1 < " + symbolicForBound.Name, bodyConstraints[1].Condition.ToString());
}
++change;
};
e.Run(main);
Assert.AreEqual(3, tc.NumberOfTerminatedStates);
Assert.AreEqual(3, tc.Sucesses);
Assert.AreEqual(2, contextChangeCount);
}
public void RemoveOneConstraintBasedOnVarsAndFunctions()
{
IConstraintManager CM = new ConstraintManager();
var builder = GetBuilder();
// Dummy Boogie variable
var bv8Type = Microsoft.Boogie.Type.GetBvType(8);
var bv8TypeIdent = new TypedIdent(Token.NoToken, "bv8", bv8Type);
var dummyVarBv = new GlobalVariable(Token.NoToken, bv8TypeIdent);
// dummyVar needs a programLocation, otherwise SymbolicVariable constructor raises an exception
var progLoc = new ProgramLocation(dummyVarBv);
dummyVarBv.SetMetadata <ProgramLocation>((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, progLoc);
var s0 = new SymbolicVariable("s0", dummyVarBv).Expr;
var s1 = new SymbolicVariable("s1", dummyVarBv).Expr;
var s2 = new SymbolicVariable("s2", dummyVarBv).Expr;
// Construct some constraints
Expr c0 = builder.Eq(builder.BVAND(s0, s1), builder.ConstantBV(0, 8));
Expr c1 = builder.Eq(s2, builder.ConstantBV(1, 8));
var FCB = new FunctionCallBuilder();
var foobarFunc = FCB.CreateUninterpretedFunctionCall("foobar", bv8Type, new List <Microsoft.Boogie.Type>()
{
bv8Type
});
// foobar(0bv8) == 0bv8
Expr c2 = builder.Eq(builder.UFC(foobarFunc, builder.ConstantBV(0, 8)), builder.ConstantBV(0, 8));
CM.AddConstraint(c0, progLoc);
CM.AddConstraint(c1, progLoc);
CM.AddConstraint(c2, progLoc);
var mockSolver = new MockSolver();
var indepenceSolver = new Symbooglix.Solver.ConstraintIndependenceSolver(mockSolver);
// The query expression does not use the "foobar" function so we don't need to keep constraints on that function
Expr queryExpr = builder.Eq(builder.BVAND(s1, s2), builder.ConstantBV(0, 8));
indepenceSolver.ComputeSatisfiability(new Solver.Query(CM, new Constraint(queryExpr)));
// Check no constraints were removed
Assert.AreEqual(2, mockSolver.Constraints.Count);
Assert.AreSame(queryExpr, mockSolver.QueryExpr);
bool c0Found = false;
bool c1Found = false;
foreach (var constraint in mockSolver.Constraints)
{
if (c0 == constraint.Condition)
{
c0Found = true;
}
if (c1 == constraint.Condition)
{
c1Found = true;
}
}
Assert.IsTrue(c0Found);
Assert.IsTrue(c1Found);
}
