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