/// <summary>
/// Creates a top or bottom elements, according to parameter "top".
/// </summary>
public PolyhedraLatticeElement(bool top) {
if (top) {
lcs = new LinearConstraintSystem(new ArrayList /*LinearConstraint*/ ());
} else {
lcs = new LinearConstraintSystem();
}
}
public LinearConstraintSystem WidenX(LinearConstraintSystem lcs){
public LinearConstraintSystem Widen(LinearConstraintSystem lcs)
{
Console.WriteLine("===================================================================================");
Console.WriteLine("DEBUG: Widen");
Console.WriteLine("Widen: this=");
Dump();
Console.WriteLine("Widen: lcs=");
lcs.Dump();
LinearConstraintSystem z = WidenX(lcs);
Console.WriteLine("----------Widen------------------------------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
Console.WriteLine("Widen: result=");
z.Dump();
Console.WriteLine("===================================================================================");
return z;
}
public LinearConstraintSystem/*!*/ Join(LinearConstraintSystem/*!*/ lcs) {
Contract.Requires(lcs != null);
Contract.Ensures(Contract.Result<LinearConstraintSystem>() != null);
#endif
if (this.IsBottom()) {
return cce.NonNull(lcs.Clone());
} else if (lcs.IsBottom()) {
return cce.NonNull(this.Clone());
} else if (this.IsTop() || lcs.IsTop()) {
return new LinearConstraintSystem(new ArrayList /*LinearConstraint*/ ());
} else {
LinearConstraintSystem/*!*/ z;
// Start from the "larger" of the two frames (this is just a heuristic measure intended
// to save work).
Contract.Assume(this.FrameVertices != null);
Contract.Assume(this.FrameRays != null);
Contract.Assume(this.FrameLines != null);
Contract.Assume(lcs.FrameVertices != null);
Contract.Assume(lcs.FrameRays != null);
Contract.Assume(lcs.FrameLines != null);
if (this.FrameVertices.Count + this.FrameRays.Count + this.FrameLines.Count - this.FrameDimensions.Count <
lcs.FrameVertices.Count + lcs.FrameRays.Count + lcs.FrameLines.Count - lcs.FrameDimensions.Count) {
z = cce.NonNull(lcs.Clone());
lcs = this;
} else {
z = cce.NonNull(this.Clone());
}
#if DEBUG_PRINT
Console.WriteLine("DEBUG: LinearConstraintSystem.Join ---------------");
Console.WriteLine("z:");
z.Dump();
Console.WriteLine("lcs:");
lcs.Dump();
#endif
// Start by explicating the implicit lines of z for the dimensions dims(lcs)-dims(z).
foreach (IVariable/*!*/ dim in lcs.FrameDimensions) {
Contract.Assert(dim != null);
if (!z.FrameDimensions.Contains(dim)) {
z.FrameDimensions.Add(dim);
FrameElement line = new FrameElement();
line.AddCoordinate(dim, Rational.ONE);
// Note: AddLine is not called (because the line already exists in z--it's just that
// it was represented implicitly). Instead, just tack the explicit representation onto
// FrameLines.
Contract.Assume(z.FrameLines != null);
z.FrameLines.Add(line);
#if DEBUG_PRINT
Console.WriteLine("Join: After explicating line: {0}", line);
z.Dump();
#endif
}
}
// Now, the vertices, rays, and lines can be added.
foreach (FrameElement/*!*/ v in lcs.FrameVertices) {
Contract.Assert(v != null);
z.AddVertex(v);
#if DEBUG_PRINT
Console.WriteLine("Join: After adding vertex: {0}", v);
z.Dump();
#endif
}
foreach (FrameElement/*!*/ r in lcs.FrameRays) {
Contract.Assert(r != null);
z.AddRay(r);
#if DEBUG_PRINT
Console.WriteLine("Join: After adding ray: {0}", r);
z.Dump();
#endif
}
foreach (FrameElement/*!*/ l in lcs.FrameLines) {
Contract.Assert(l != null);
z.AddLine(l);
#if DEBUG_PRINT
Console.WriteLine("Join: After adding line: {0}", l);
z.Dump();
#endif
}
// also add to z the implicit lines of lcs
foreach (IVariable/*!*/ dim in z.FrameDimensions) {
Contract.Assert(dim != null);
if (!lcs.FrameDimensions.Contains(dim)) {
// "dim" is a dimension that's explicit in "z" but implicit in "lcs"
FrameElement line = new FrameElement();
line.AddCoordinate(dim, Rational.ONE);
z.AddLine(line);
#if DEBUG_PRINT
Console.WriteLine("Join: After adding lcs's implicit line: {0}", line);
z.Dump();
#endif
}
}
z.SimplifyFrame();
z.SimplifyConstraints();
z.CheckInvariant();
#if DEBUG_PRINT
Console.WriteLine("Join: Returning z:");
z.Dump();
Console.WriteLine("----------------------------------------");
#endif
return z;
}
}
/// <summary>
/// The join is computed as described in section 4.4 in Cousot and Halbwachs.
/// </summary>
/// <param name="lcs"></param>
/// <returns></returns>
#if DEBUG_PRINT
public LinearConstraintSystem JoinX(LinearConstraintSystem lcs) {
public LinearConstraintSystem Join(LinearConstraintSystem lcs)
{
Console.WriteLine("===================================================================================");
Console.WriteLine("DEBUG: Join");
Console.WriteLine("Join: this=");
Dump();
Console.WriteLine("Join: lcs=");
lcs.Dump();
LinearConstraintSystem z = JoinX(lcs);
Console.WriteLine("----------Join------------------------------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
Console.WriteLine("Join: result=");
z.Dump();
Console.WriteLine("===================================================================================");
return z;
}
public LinearConstraintSystem/*!*/ Meet(LinearConstraintSystem/*!*/ lcs) {
Contract.Requires(lcs != null);
Contract.Requires((this.Constraints != null));
Contract.Requires((lcs.Constraints != null));
Contract.Ensures(Contract.Result<LinearConstraintSystem>() != null);
ArrayList /*LinearConstraint*/ clist = new ArrayList(this.Constraints.Count + lcs.Constraints.Count);
clist.AddRange(this.Constraints);
clist.AddRange(lcs.Constraints);
return new LinearConstraintSystem(clist);
}
public override Element/*!*/ Constrain(Element/*!*/ e, IExpr/*!*/ expr) {
//Contract.Requires(expr != null);
//Contract.Requires(e != null);
Contract.Ensures(Contract.Result<Element>() != null);
log.DbgMsg(string.Format("Constraining with {0} into {1} ...", expr, this.ToString(e)));
PolyhedraLatticeElement ple = (PolyhedraLatticeElement)e;
if (ple.lcs.IsBottom()) {
return ple;
}
LinearCondition le = LinearExpressionBuilder.AsCondition(expr);
if (le != null) {
// update the polyhedron according to the linear expression
Contract.Assume(ple.lcs.Constraints != null);
ArrayList /*LinearConstraint*/ clist = (ArrayList/*!*/ /*LinearConstraint*/)cce.NonNull(ple.lcs.Constraints.Clone());
le.AddToConstraintSystem(clist);
LinearConstraintSystem newLcs = new LinearConstraintSystem(clist);
return new PolyhedraLatticeElement(newLcs);
}
return ple;
}
public static void RunValidationC() {
// Run the example in section 3.4.3 of Cousot and Halbwachs backwards, that is, from
// from to constraints.
IVariable/*!*/ dim1 = new TestVariable("X");
IVariable/*!*/ dim2 = new TestVariable("Y");
IVariable/*!*/ dim3 = new TestVariable("Z");
Contract.Assert(dim1 != null);
Contract.Assert(dim2 != null);
Contract.Assert(dim3 != null);
FrameElement s0 = new FrameElement();
s0.AddCoordinate(dim1, Rational.ONE);
s0.AddCoordinate(dim2, Rational.FromInts(1, 2));
s0.AddCoordinate(dim3, Rational.FromInts(-1, 2));
FrameElement s1 = new FrameElement();
s1.AddCoordinate(dim1, Rational.ONE);
s1.AddCoordinate(dim2, Rational.FromInts(-1, 2));
s1.AddCoordinate(dim3, Rational.FromInts(1, 2));
FrameElement s2 = new FrameElement();
s2.AddCoordinate(dim1, Rational.FromInt(3));
s2.AddCoordinate(dim2, Rational.FromInts(-3, 2));
s2.AddCoordinate(dim3, Rational.FromInts(3, 2));
FrameElement r0 = new FrameElement();
r0.AddCoordinate(dim1, Rational.ONE);
r0.AddCoordinate(dim2, Rational.FromInts(1, 2));
r0.AddCoordinate(dim3, Rational.FromInts(-1, 2));
FrameElement r1 = new FrameElement();
r1.AddCoordinate(dim1, Rational.ONE);
r1.AddCoordinate(dim2, Rational.ZERO);
r1.AddCoordinate(dim3, Rational.ZERO);
FrameElement d0 = new FrameElement();
d0.AddCoordinate(dim1, Rational.ZERO);
d0.AddCoordinate(dim2, Rational.ONE);
d0.AddCoordinate(dim3, Rational.ONE);
LinearConstraintSystem lcs = new LinearConstraintSystem(s0);
lcs.Dump();
lcs.AddVertex(s1);
lcs.Dump();
lcs.AddVertex(s2);
lcs.Dump();
lcs.AddRay(r0);
lcs.Dump();
lcs.AddRay(r1);
lcs.Dump();
lcs.AddLine(d0);
lcs.Dump();
lcs.SimplifyConstraints();
lcs.Dump();
#if LATER
lcs.GenerateFrameFromConstraints(); // should give us back the original frame...
#endif
}
/// <summary>
/// Tests the example in section 3.4.3 of Cousot and Halbwachs.
/// </summary>
public static void RunValidationB() {
IVariable/*!*/ X = new TestVariable("X");
IVariable/*!*/ Y = new TestVariable("Y");
IVariable/*!*/ Z = new TestVariable("Z");
Contract.Assert(X != null);
Contract.Assert(Y != null);
Contract.Assert(Z != null);
ArrayList /*LinearConstraint*/ cs = new ArrayList /*LinearConstraint*/ ();
LinearConstraint c = new LinearConstraint(LinearConstraint.ConstraintRelation.LE);
c.SetCoefficient(X, Rational.MINUS_ONE);
c.SetCoefficient(Y, Rational.ONE);
c.SetCoefficient(Z, Rational.MINUS_ONE);
c.rhs = Rational.ZERO;
cs.Add(c);
c = new LinearConstraint(LinearConstraint.ConstraintRelation.LE);
c.SetCoefficient(X, Rational.MINUS_ONE);
c.rhs = Rational.MINUS_ONE;
cs.Add(c);
c = new LinearConstraint(LinearConstraint.ConstraintRelation.LE);
c.SetCoefficient(X, Rational.MINUS_ONE);
c.SetCoefficient(Y, Rational.MINUS_ONE);
c.SetCoefficient(Z, Rational.ONE);
c.rhs = Rational.ZERO;
cs.Add(c);
c = new LinearConstraint(LinearConstraint.ConstraintRelation.LE);
c.SetCoefficient(Y, Rational.MINUS_ONE);
c.SetCoefficient(Z, Rational.ONE);
c.rhs = Rational.FromInt(3);
cs.Add(c);
LinearConstraintSystem lcs = new LinearConstraintSystem(cs);
Console.WriteLine("==================== The final linear constraint system ====================");
lcs.Dump();
}
public static void RunValidationA() {
IVariable/*!*/ dim1 = new TestVariable("X");
IVariable/*!*/ dim2 = new TestVariable("Y");
IVariable/*!*/ dim3 = new TestVariable("Z");
Contract.Assert(dim1 != null);
Contract.Assert(dim2 != null);
Contract.Assert(dim3 != null);
FrameElement s1 = new FrameElement();
s1.AddCoordinate(dim1, Rational.ONE);
s1.AddCoordinate(dim2, Rational.MINUS_ONE);
s1.AddCoordinate(dim3, Rational.ZERO);
FrameElement s2 = new FrameElement();
s2.AddCoordinate(dim1, Rational.MINUS_ONE);
s2.AddCoordinate(dim2, Rational.ONE);
s2.AddCoordinate(dim3, Rational.ZERO);
FrameElement r1 = new FrameElement();
r1.AddCoordinate(dim1, Rational.ZERO);
r1.AddCoordinate(dim2, Rational.ZERO);
r1.AddCoordinate(dim3, Rational.ONE);
FrameElement d1 = new FrameElement();
d1.AddCoordinate(dim1, Rational.ONE);
d1.AddCoordinate(dim2, Rational.ONE);
d1.AddCoordinate(dim3, Rational.ZERO);
// create lcs from frame -- cf. Cousot/Halbwachs 1978, section 3.3.1.1
LinearConstraintSystem lcs = new LinearConstraintSystem(s1);
lcs.Dump();
lcs.AddVertex(s2);
lcs.Dump();
lcs.AddRay(r1);
lcs.Dump();
lcs.AddLine(d1);
lcs.Dump();
lcs.SimplifyConstraints();
lcs.Dump();
#if LATER
lcs.GenerateFrameFromConstraints(); // should give us back the original frame...
#endif
Console.WriteLine("IsSubset? {0}", lcs.IsSubset(lcs.Clone()));
lcs.Dump();
}
// --------------------------------------------------------------------------------------------------------
// ------------------ Cloning routines --------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------
public LinearConstraintSystem/*!*/ Clone() {
Contract.Ensures(Contract.Result<LinearConstraintSystem>() != null);
LinearConstraintSystem z = new LinearConstraintSystem();
z.FrameDimensions = (IMutableSet /*IVariable!*//*!*/)cce.NonNull(this.FrameDimensions.Clone());
if (this.Constraints != null) {
z.Constraints = DeeperListCopy_LC(this.Constraints);
z.FrameVertices = DeeperListCopy_FE(cce.NonNull(this.FrameVertices));
z.FrameRays = DeeperListCopy_FE(cce.NonNull(this.FrameRays));
z.FrameLines = DeeperListCopy_FE(cce.NonNull(this.FrameLines));
} else {
System.Diagnostics.Debug.Assert(this.FrameVertices == null);
System.Diagnostics.Debug.Assert(this.FrameRays == null);
System.Diagnostics.Debug.Assert(this.FrameLines == null);
// the constructor should already have set these fields of z to null
System.Diagnostics.Debug.Assert(z.Constraints == null);
System.Diagnostics.Debug.Assert(z.FrameVertices == null);
System.Diagnostics.Debug.Assert(z.FrameRays == null);
System.Diagnostics.Debug.Assert(z.FrameLines == null);
}
return z;
}
public PolyhedraLatticeElement(LinearConstraintSystem/*!*/ lcs) {
Contract.Requires(lcs != null);
this.lcs = lcs;
}
public LinearConstraintSystem/*!*/ Widen(LinearConstraintSystem/*!*/ lcs) {
Contract.Requires(lcs != null);
Contract.Ensures(Contract.Result<LinearConstraintSystem>() != null);
#endif
if (this.IsBottom()) {
return cce.NonNull(lcs.Clone());
} else if (lcs.IsBottom()) {
return cce.NonNull(this.Clone());
} else if (this.IsTop() || lcs.IsTop()) {
return new LinearConstraintSystem(new ArrayList /*LinearConstraint*/ ());
}
// create new LCS, we will add only verified constraints to this...
ArrayList /*LinearConstraint*/ newConstraints = new ArrayList /*LinearConstraint*/ ();
Contract.Assume(this.Constraints != null);
foreach (LinearConstraint/*!*/ ccX in this.Constraints) {
Contract.Assert(ccX != null);
LinearConstraint cc = ccX;
#if DEBUG_PRINT
Console.WriteLine("Widen checking: Starting to check constraint: {0}", cc);
#endif
if (cc.IsConstant()) {
// (Can this ever occur in the stable state of a LinearConstraintSystem? --KRML)
// constraint is unaffected by the frame components
#if DEBUG_PRINT
Console.WriteLine("Widen checking: --Adding it!");
#endif
newConstraints.Add(cc);
continue;
}
// PHASE I: verify constraints against all frame vertices...
foreach (FrameElement/*!*/ vertex in cce.NonNull(lcs.FrameVertices)) {
Contract.Assert(vertex != null);
Rational lhs = cc.EvaluateLhs(vertex);
if (lhs > cc.rhs) {
// the vertex does not satisfy the inequality <=
if (cc.Relation == LinearConstraint.ConstraintRelation.LE) {
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out because of vertex: {0}", vertex);
#endif
goto CHECK_NEXT_CONSTRAINT;
} else {
// ... but it does satisfy the inequality >=
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out <= because of vertex: {0}", vertex);
#endif
cc = cc.ChangeRelationToAtLeast();
#if DEBUG_PRINT
Console.WriteLine("Widen checking: left with constraint: {0}", cc);
#endif
}
} else if (cc.Relation == LinearConstraint.ConstraintRelation.EQ && lhs < cc.rhs) {
// the vertex does not satisfy the inequality >=, and the constraint is an equality constraint
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out >= because of vertex: {0}", vertex);
#endif
cc = cc.ChangeRelation(LinearConstraint.ConstraintRelation.LE);
#if DEBUG_PRINT
Console.WriteLine("Widen checking: left with contraint: {0}", cc);
#endif
}
}
// PHASE II: verify constraints against all frame rays...
foreach (FrameElement/*!*/ ray in cce.NonNull(lcs.FrameRays)) {
Contract.Assert(ray != null);
// The following assumes the constraint to have some dimension with a non-zero coefficient
Rational lhs = cc.EvaluateLhs(ray);
if (lhs.IsPositive) {
// the ray does not satisfy the inequality <=
if (cc.Relation == LinearConstraint.ConstraintRelation.LE) {
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out because of ray: {0}", ray);
#endif
goto CHECK_NEXT_CONSTRAINT;
} else {
// ... but it does satisfy the inequality >=
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out <= because of ray: {0}", ray);
#endif
cc = cc.ChangeRelationToAtLeast();
#if DEBUG_PRINT
Console.WriteLine("Widen checking: left with contraint: {0}", cc);
#endif
}
} else if (cc.Relation == LinearConstraint.ConstraintRelation.EQ && lhs.IsNegative) {
// the ray does not satisfy the inequality >=, and the constraint is an equality constraint
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out >= because of ray: {0}", ray);
#endif
cc = cc.ChangeRelation(LinearConstraint.ConstraintRelation.LE);
#if DEBUG_PRINT
Console.WriteLine("Widen checking: left with constraint: {0}", cc);
#endif
}
}
// PHASE III: verify constraints against all frame lines...
foreach (FrameElement/*!*/ line in cce.NonNull(lcs.FrameLines)) {
Contract.Assert(line != null);
// The following assumes the constraint to have some dimension with a non-zero coefficient
Rational lhs = cc.EvaluateLhs(line);
if (!lhs.IsZero) {
// The line satisfies neither the inequality <= nor the equality ==
#if DEBUG_PRINT
Console.WriteLine("Widen checking: throwing out because of line: {0}", line);
#endif
goto CHECK_NEXT_CONSTRAINT;
}
}
// constraint has been verified, so add to new constraint system
#if DEBUG_PRINT
Console.WriteLine("Widen checking: --Adding it!");
#endif
newConstraints.Add(cc);
CHECK_NEXT_CONSTRAINT: {
}
#if DEBUG_PRINT
Console.WriteLine("Widen checking: done with that constraint");
#endif
}
return new LinearConstraintSystem(newConstraints);
}
/* IsSubset(): determines if 'lcs' is a subset of 'this'
* -- See Cousot/Halbwachs 1978, section
*/
public bool IsSubset(LinearConstraintSystem/*!*/ lcs) {
Contract.Requires(lcs != null);
if (lcs.IsBottom()) {
return true;
} else if (this.IsBottom()) {
return false;
#if DEBUG
#else
} else if (this.IsTop()) { // optimization -- this case not needed for correctness
return true;
} else if (lcs.IsTop()) { // optimization -- this case not needed for correctness
return false;
#endif
} else {
// phase 0: check if frame dimensions are a superset of the constraint dimensions
ISet /*IVariable!*//*!*/ frameDims = lcs.GetDefinedDimensions();
Contract.Assert(frameDims != null);
#if DEBUG_PRINT
Console.WriteLine("DEBUG: IsSubset:");
Console.WriteLine(" --- this:");
this.Dump();
Console.WriteLine(" --- lcs:");
lcs.Dump();
Console.WriteLine(" ---");
#endif
foreach (LinearConstraint/*!*/ cc in cce.NonNull(this.Constraints)) {
Contract.Assert(cc != null);
#if DEBUG_PRINT
Console.WriteLine(" cc: {0}", cc);
Console.WriteLine(" cc.GetDefinedDimensions(): {0}", cc.GetDefinedDimensions());
#endif
if (!Contract.ForAll(cc.GetDefinedDimensionsGeneric(), var => frameDims.Contains(var))) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 0 subset violated, return false from IsSubset");
#endif
return false;
}
}
}
// phase 1: check frame vertices against each constraint...
foreach (FrameElement/*!*/ v in cce.NonNull(lcs.FrameVertices)) {
Contract.Assert(v != null);
foreach (LinearConstraint/*!*/ cc in this.Constraints) {
Contract.Assert(cc != null);
Rational q = cc.EvaluateLhs(v);
if (cc.Relation == LinearConstraint.ConstraintRelation.LE) {
if (!(q <= cc.rhs)) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 1a subset violated, return false from IsSubset");
#endif
return false;
}
} else {
if (!(q == cc.rhs)) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 1b subset violated, return false from IsSubset");
#endif
return false;
}
}
}
}
// phase 2: check frame rays against each constraint...
// To check if a ray "r" falls within a constraint "cc", we add the vector "r" to
// any point "p" on the side of the half-space or plane described by constraint, and
// then check if the resulting point satisfies the constraint. That is, we check (for
// an inequality constraint with coefficients a1,a2,...,an and right-hand side
// constant C):
// a1*(r1+p1) + a2*(r2+p2) + ... + an*(rn+pn) <= C
// Equivalently:
// a1*r1 + a2*r2 + ... + an*rn + a1*p1 + a2*p2 + ... + an*pn <= C
// To find a point "p", we can pick out a coordinate, call it 1, with a non-zero
// coefficient in the constraint, and then choose "p" as the point that has the
// value C/a1 in coordinate 1 and has 0 in all other coordinates. We then check:
// a1*r1 + a2*r2 + ... + an*rn + a1*(C/a1) + a2*0 + ... + an*0 <= C
// which simplifies to:
// a1*r1 + a2*r2 + ... + an*rn + C <= C
// which in turn simplifies to:
// a1*r1 + a2*r2 + ... + an*rn <= 0
// If the constraint is an equality constraint, we simply replace "<=" with "=="
// above.
foreach (FrameElement/*!*/ r in cce.NonNull(lcs.FrameRays)) {
Contract.Assert(r != null);
System.Diagnostics.Debug.Assert(r != null, "encountered a null ray...");
foreach (LinearConstraint/*!*/ cc in this.Constraints) {
Contract.Assert(cc != null);
System.Diagnostics.Debug.Assert(cc != null, "encountered an null constraint...");
Rational q = cc.EvaluateLhs(r);
if (cc.Relation == LinearConstraint.ConstraintRelation.LE) {
if (q.IsPositive) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 2a subset violated, return false from IsSubset");
#endif
return false;
}
} else {
if (q.IsNonZero) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 2b subset violated, return false from IsSubset");
#endif
return false;
}
}
}
}
// phase 3: check frame lines against each constraint...
// To check if a line "L" falls within a constraint "cc", we check if both the
// vector "L" and "-L", interpreted as rays, fall within the constraint. From
// the discussion above, this means we check the following two properties:
// a1*L1 + a2*L2 + ... + an*Ln <= 0 (*)
// a1*(-L1) + a2*(-L2) + ... + an*(-Ln) <= 0
// The second of these lines can be rewritten as:
// - a1*L1 - a2*L2 - ... - an*Ln <= 0
// which is equivalent to:
// -1 * (a1*L1 + a2*L2 + ... + an*Ln) <= 0
// Multiplying both sides by -1 and flipping the direction of the inequality,
// we have:
// a1*L1 + a2*L2 + ... + an*Ln >= 0 (**)
// Putting (*) and (**) together, we conclude that we need to check:
// a1*L1 + a2*L2 + ... + an*Ln == 0
// If the constraint is an equality constraint, we end up with the same equation.
foreach (FrameElement/*!*/ line in cce.NonNull(lcs.FrameLines)) {
Contract.Assert(line != null);
System.Diagnostics.Debug.Assert(line != null, "encountered a null line...");
foreach (LinearConstraint/*!*/ cc in this.Constraints) {
Contract.Assert(cc != null);
System.Diagnostics.Debug.Assert(cc != null, "encountered an null constraint...");
Rational q = cc.EvaluateLhs(line);
if (q.IsNonZero) {
#if DEBUG_PRINT
Console.WriteLine(" ---> phase 3 subset violated, return false from IsSubset");
#endif
return false;
}
}
}
#if DEBUG_PRINT
Console.WriteLine(" ---> IsSubset returns true");
#endif
return true;
}
public LinearConstraintSystem/*!*/ Rename(IVariable/*!*/ oldName, IVariable/*!*/ newName) {
Contract.Requires(oldName != null);
Contract.Requires(newName != null);
Contract.Ensures(Contract.Result<LinearConstraintSystem>() != null);
#endif
if (this.Constraints == null) {
System.Diagnostics.Debug.Assert(this.FrameVertices == null);
System.Diagnostics.Debug.Assert(this.FrameRays == null);
System.Diagnostics.Debug.Assert(this.FrameLines == null);
return this;
}
IMutableSet /*IVariable!*//*!*/ dims = this.FrameDimensions;
Contract.Assert(dims != null);
if (!dims.Contains(oldName)) {
return this;
}
LinearConstraintSystem z = new LinearConstraintSystem();
z.FrameDimensions = cce.NonNull((HashSet/*!*/ /*IVariable!*/)dims.Clone());
z.FrameDimensions.Remove(oldName);
z.FrameDimensions.Add(newName);
z.Constraints = new ArrayList /*LinearConstraint!*/ (this.Constraints.Count);
foreach (LinearConstraint/*!*/ lc in cce.NonNull(this.Constraints)) {
Contract.Assert(lc != null);
z.Constraints.Add(lc.Rename(oldName, newName));
}
z.FrameVertices = RenameInFE(cce.NonNull(this.FrameVertices), oldName, newName);
z.FrameRays = RenameInFE(cce.NonNull(this.FrameRays), oldName, newName);
z.FrameLines = RenameInFE(cce.NonNull(this.FrameLines), oldName, newName);
return z;
}
public override Answer CheckVariableDisequality(Element/*!*/ e, IVariable/*!*/ var1, IVariable/*!*/ var2) {
//Contract.Requires(var2 != null);
//Contract.Requires(var1 != null);
//Contract.Requires(e != null);
PolyhedraLatticeElement/*!*/ ple = (PolyhedraLatticeElement)cce.NonNull(e);
Contract.Assume(ple.lcs.Constraints != null);
ArrayList /*LinearConstraint!*//*!*/ clist = (ArrayList /*LinearConstraint!*/)cce.NonNull(ple.lcs.Constraints.Clone());
LinearConstraint/*!*/ lc = new LinearConstraint(LinearConstraint.ConstraintRelation.EQ);
Contract.Assert(lc != null);
lc.SetCoefficient(var1, Rational.ONE);
lc.SetCoefficient(var2, Rational.MINUS_ONE);
clist.Add(lc);
LinearConstraintSystem newLcs = new LinearConstraintSystem(clist);
if (newLcs.IsBottom()) {
return Answer.Yes;
} else {
return Answer.Maybe;
}
}
