public void FromStringPositive() { var v = BigDec.FromString("1.5"); Assert.AreEqual(-1, v.Exponent); Assert.AreEqual(new BigInteger(15.0), v.Mantissa); }
///////////////////////////////////////////////////////////////////////////////////// public bool Visit(VCExprLiteral node, LineariserOptions options) { if (node == VCExpressionGenerator.True) { wr.Write("true"); } else if (node == VCExpressionGenerator.False) { wr.Write("false"); } else if (node is VCExprIntLit) { BigNum lit = ((VCExprIntLit)node).Val; if (lit.IsNegative) { // In SMT2 "-42" is an identifier (SMT2, Sect. 3.2 "Symbols") wr.Write("(- 0 {0})", lit.Abs); } else { wr.Write(lit); } } else if (node is VCExprRealLit) { BigDec lit = ((VCExprRealLit)node).Val; if (lit.IsNegative) { // In SMT2 "-42" is an identifier (SMT2, Sect. 3.2 "Symbols") wr.Write("(- 0.0 {0})", lit.Abs.ToDecimalString()); } else { wr.Write(lit.ToDecimalString()); } } else if (node is VCExprFloatLit) { BigFloat lit = ((VCExprFloatLit)node).Val; wr.Write("(" + lit.ToBVString() + ")"); } else if (node is VCExprRModeLit) { RoundingMode lit = ((VCExprRModeLit)node).Val; wr.Write(lit.ToString()); } else if (node is VCExprStringLit) { String lit = ((VCExprStringLit)node).Val; wr.Write("\"" + lit.ToString() + "\""); } else { Contract.Assert(false); throw new cce.UnreachableException(); } return(true); }
public void NegativeRealFromBigDec() { var builder = GetSimpleBuilder(); var constant = builder.ConstantReal(BigDec.FromInt(-5)); Assert.AreEqual("-5e0", constant.ToString()); CheckType(constant, t => t.IsReal); }
public void LiteralReal() { var constant = new LiteralExpr(Token.NoToken, BigDec.FromString("11.7")); // Real var constant2 = new LiteralExpr(Token.NoToken, BigDec.FromString("11.7")); // Real Assert.AreNotSame(constant, constant2); // These are different references Assert.IsTrue(constant.Equals(constant2)); // These are "structurally equal" Assert.AreEqual(constant.GetHashCode(), constant2.GetHashCode()); // If the .Equals() is true then hash codes must be the same }
public void FromStringNegative() { // This tests for a Bug in Boogie that used to be present where BigDec // would not parse strings with negative numbers correctly // // If this bug is present this test will fail when checking the mantissa var v = BigDec.FromString("-1.5"); Assert.AreEqual(-1, v.Exponent); Assert.AreEqual(new BigInteger(-15.0), v.Mantissa); }
public void testReal(bool useStringInterface) { var ccB = new ConstantCachingExprBuilder(this.GetSimpleBuilder()); for (BigDec value = BigDec.FromInt(-20); value <= BigDec.FromInt(20); value += BigDec.FromString("0.1")) { var asString = value.ToString(); var realExpr = useStringInterface ? ccB.ConstantReal(asString) : ccB.ConstantReal(value); var realExpr2 = useStringInterface ? ccB.ConstantReal(asString) : ccB.ConstantReal(value); Assert.AreSame(realExpr, realExpr2); } }
public override LiteralExpr ConstantReal(BigDec value) { try { var cachedReal = RealCache[value]; Debug.Assert(cachedReal.isBigDec); return(cachedReal); } catch (KeyNotFoundException) { var newReal = UB.ConstantReal(value); Debug.Assert(newReal.isBigDec); RealCache.Add(value, newReal); return(newReal); } }
public void FloorAndCeil(string value, int expectedFloor, int expectedCeiling) { var v = BigDec.FromString(value); if (value.StartsWith("-")) { Assert.IsTrue(v.IsNegative); } else { Assert.IsTrue(v.IsPositive || v.IsZero); } BigInteger floor = 0; BigInteger ceiling = 0; v.FloorCeiling(out floor, out ceiling); Assert.AreEqual(new BigInteger(expectedFloor), floor); Assert.AreEqual(new BigInteger(expectedCeiling), ceiling); }
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(); } }
public VCExpr /*!*/ Real(BigDec x) { Contract.Ensures(Contract.Result <VCExpr>() != null); return(new VCExprRealLit(x)); }
public override LiteralExpr ConstantReal(string value) { return(this.ConstantReal(BigDec.FromString(value))); }
public virtual LiteralExpr ConstantReal(BigDec value) { return(UB.ConstantReal(value)); }
public LiteralExpr ConstantReal(string value) { return(new LiteralExpr(Token.NoToken, BigDec.FromString(value), Immutable)); }