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