def testDiffBothArity(self):
from iegen import Relation
from iegen.parser import PresParser
relation1=PresParser.parse_relation('{[a]->[b]:a>10}')
relation2=PresParser.parse_relation('{[a,b]->[a,b]:b>10}')
Relation(relations=[relation1,relation2])
def testRelationsWhtSymbolics(self):
from iegen import Relation,Symbolic
from iegen.parser import PresParser
relation1=PresParser.parse_relation('{[a]->[b]:a>10 and a<n}',[Symbolic('n')])
relation2=PresParser.parse_relation('{[b]->[c]:b>10 and b<m}',[Symbolic('m')])
relation=Relation(relations=[relation1,relation2])
def testRelations(self):
from iegen import Relation
from iegen.parser import PresParser
relation1=PresParser.parse_relation('{[a]->[b]:a>10}')
relation2=PresParser.parse_relation('{[b]->[c]:b>10}')
relation=Relation(relations=[relation1,relation2])
def testOrder(self):
from iegen import Relation
from iegen.parser import PresParser
prelation1=PresParser.parse_relation('{[a]->[a]:a>10}')
prelation2=PresParser.parse_relation('{[b]->[b]:b>11}')
relation1=Relation(relations=[prelation1,prelation2])
prelation1=PresParser.parse_relation('{[a]->[a]:a>11}')
prelation2=PresParser.parse_relation('{[b]->[b]:b>10}')
relation2=Relation(relations=[prelation1,prelation2])
self.failUnless(relation1==relation2,'%s!=%s'%(relation1,relation2))
def testCollectTwice(self):
from iegen.ast.visitor import CollectVarsVisitor
from iegen.ast import Equality, NormExp, VarExp
from iegen.parser import PresParser
from iegen import Symbolic
rel = PresParser.parse_relation("{[a]->[b]: a=n}", [Symbolic("n")])
v = CollectVarsVisitor(all_vars=True).visit(rel)
rel = PresParser.parse_relation("{[c]->[d]: c=n}", [Symbolic("n")])
v.visit(rel)
res = ["a", "b", "c", "d", "n"]
self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testThreeVarsRelation(self):
from iegen.ast.visitor import CollectVarsVisitor
from iegen import Symbolic
from iegen.parser import PresParser
rel = PresParser.parse_relation("{[a]->[b,c]: a=1 and b=c}")
v = CollectVarsVisitor().visit(rel)
res = ["a", "b", "c"]
self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
rel = PresParser.parse_relation("{[a,b]->[c]: a=1 and b=n}", [Symbolic("n")])
v = CollectVarsVisitor().visit(rel)
res = ["a", "b", "c"]
self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testNoVarsRelation(self):
from iegen.ast.visitor import CollectVarsVisitor
from iegen.parser import PresParser
rel = PresParser.parse_relation("{[]->[]}")
v = CollectVarsVisitor().visit(rel)
res = []
self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testIsTupleSearchVarTuple(self):
from iegen.ast.visitor import IsVarVisitor
from iegen.parser import PresParser
set = PresParser.parse_set("{[a]}")
relation = PresParser.parse_relation("{[a]->[b]}")
self.failUnless(IsVarVisitor("a").visit(set).is_tuple_var, "'a' is a not tuple var in %s" % set)
self.failUnless(IsVarVisitor("a").visit(relation).is_tuple_var, "'a' is a not tuple var in %s" % relation)
self.failUnless(IsVarVisitor("b").visit(relation).is_tuple_var, "'b' is a not tuple var in %s" % relation)
def testIsConstraintNoSearchVarTuple(self):
from iegen.ast.visitor import IsVarVisitor
from iegen.parser import PresParser
set = PresParser.parse_set("{[a]}")
relation = PresParser.parse_relation("{[a]->[b]}")
self.failIf(IsVarVisitor("a").visit(set).is_constraint_var, "'a' is a constraint var in %s" % set)
self.failIf(IsVarVisitor("a").visit(relation).is_constraint_var, "'a' is a constraint var in %s" % relation)
self.failIf(IsVarVisitor("b").visit(relation).is_constraint_var, "'b' is a constraint var in %s" % relation)
def testOneVarRelation(self):
from iegen.ast.visitor import CollectVarsVisitor
from iegen import Symbolic
from iegen.parser import PresParser
rel = PresParser.parse_relation("{[a]->[]: a=n}", [Symbolic("n")])
v = CollectVarsVisitor().visit(rel)
res = ["a"]
self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testInverse(self):
from iegen import Relation
from iegen.parser import PresParser
relation=Relation('{[a,b]->[c,d]}')
prelation=PresParser.parse_relation('{[c,d]->[a,b]}')
inverse=relation.inverse()
inverse_res=Relation(relations=[prelation])
self.failUnless(inverse==inverse_res,'%s!=%s'%(inverse,inverse_res))
def testInverseConstraints(self):
from iegen import Relation
from iegen.parser import PresParser
relation=Relation('{[a,b]->[c,d]:a>=n && b<5 and c+d=15}')
prelation=PresParser.parse_relation('{[c,d]->[a,b]:b<5 and a>=n && c+d=15}')
inverse=relation.inverse()
inverse_res=Relation(relations=[prelation])
self.failUnless(inverse==inverse_res,'%s!=%s'%(inverse,inverse_res))
def testEmptyRelation(self):
from iegen.ast.visitor import UniqueTupleVarsVisitor
from iegen.ast import PresRelation, VarTuple, Conjunction
from iegen.parser import PresParser
rel = PresRelation(VarTuple([]), VarTuple([]), Conjunction([]))
changed = UniqueTupleVarsVisitor().visit(rel).changed
rel_res = PresParser.parse_relation("{[]->[]}")
self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel))
self.failUnless(False == changed, "changed!=False")
def testRenameRelationSimple3(self):
from iegen.ast.visitor import UniqueTupleVarsVisitor
from iegen.ast import PresRelation, VarTuple, Conjunction, VarExp
from iegen.parser import PresParser
rel = PresRelation(VarTuple([VarExp(1, "a")]), VarTuple([VarExp(1, "a")]), Conjunction([]))
changed = UniqueTupleVarsVisitor().visit(rel).changed
rel_res = PresParser.parse_relation("{[a]->[a0]: a=a0}")
self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel))
self.failUnless(True == changed, "changed!=True")
def testUnionRename(self):
from iegen import Relation
from iegen.parser import PresParser
prelation1=PresParser.parse_relation('{[a]->[ap]:a>10 and ap>20}')
prelation2=PresParser.parse_relation('{[a]->[ap]:a<5 and ap<10}')
prelation3=PresParser.parse_relation('{[a]->[ap]:a=7 and ap=14}')
relation1=Relation('{[a]->[ap]:a>10 and ap>20}')
relation2=Relation('{[b]->[bp]:b<5 and bp<10}')
relation3=Relation('{[c]->[cp]:c=7 and cp=14}')
unioned=relation1.union(relation2).union(relation3)
unioned_res=Relation(relations=[prelation1,prelation2,prelation3])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
prelation1=PresParser.parse_relation('{[a]->[ap]:a>10 and ap>20}')
prelation2=PresParser.parse_relation('{[a]->[ap]:a<5 and ap<10}')
prelation3=PresParser.parse_relation('{[a]->[ap]:a=7 and ap=14}')
relation1=Relation('{[a]->[ap]:a>10 and ap>20}')
relation2=Relation('{[b]->[bp]:b<5 and bp<10}')
relation3=Relation('{[c]->[cp]:c=7 and cp=14}')
unioned=unioned.union(relation1)
unioned_res=Relation(relations=[prelation1,prelation2,prelation3])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
def testIsSymSearchSymbolics(self):
from iegen.ast.visitor import IsVarVisitor
from iegen import Symbolic
from iegen.parser import PresParser
set = PresParser.parse_set("{[]}")
set.symbolics.append(Symbolic("n"))
relation = PresParser.parse_relation("{[]->[]}")
relation.symbolics.append(Symbolic("n"))
self.failUnless(IsVarVisitor("n").visit(set).is_symbolic_var, "'n' is not a symbolic var in %s" % set)
self.failUnless(IsVarVisitor("n").visit(relation).is_symbolic_var, "'n' is not a symbolic var in %s" % relation)
def testIsTupleNoSearchSymbolics(self):
from iegen.ast.visitor import IsVarVisitor
from iegen import Symbolic
from iegen.parser import PresParser
set = PresParser.parse_set("{[]}", [Symbolic("n")])
set.symbolics.append(Symbolic("n"))
relation = PresParser.parse_relation("{[]->[]}")
relation.symbolics.append(Symbolic("n"))
self.failIf(IsVarVisitor("n").visit(set).is_tuple_var, "'n' is a tuple var in %s" % set)
self.failIf(IsVarVisitor("n").visit(relation).is_tuple_var, "'n' is a tuple var in %s" % relation)
def testUnion(self):
from iegen import Relation
from iegen.parser import PresParser
prelation1=PresParser.parse_relation('{[a]->[a]:a>10}')
prelation2=PresParser.parse_relation('{[b]->[b]:b>11}')
relation1=Relation('{[a]->[a]:a>10}')
relation2=Relation('{[b]->[b]:b>11}')
unioned=relation1.union(relation2)
unioned_res=Relation(relations=[prelation1,prelation2])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
prelation1=PresParser.parse_relation('{[a]->[a]:a>10}')
prelation2=PresParser.parse_relation('{[b]->[b]:b>11}')
prelation3=PresParser.parse_relation('{[b]->[b]:b>11}')
relation1=Relation('{[a]->[a]:a>10}')
relation2=Relation('{[b]->[b]:b>11}')
unioned=unioned.union(relation1)
unioned_res=Relation(relations=[prelation1,prelation2,prelation3])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
def testStr(self):
from iegen import Relation,Symbolic
from iegen.parser import PresParser
relation_str1='{[a]->[ap]: -1a+5=0}'
prelation1=PresParser.parse_relation(relation_str1)
relation_str2='{[b]->[bp]: -1b+6=0}'
prelation2=PresParser.parse_relation(relation_str2)
relation_str3='{[c]->[cp]: -1c+7=0}'
prelation3=PresParser.parse_relation(relation_str3)
relation=Relation(relations=[prelation1])
relation_str='%s'%(relation_str1)
self.failUnless(str(relation)==relation_str,'%s!=%s'%(str(relation),relation_str))
relation=Relation(relations=[prelation1,prelation2])
relation_str='{[a]->[ap]: -1a+5=0} union {[a]->[ap]: -1a+6=0}'
self.failUnless(str(relation)==relation_str,'%s!=%s'%(str(relation),relation_str))
relation=Relation(relations=[prelation1,prelation2,prelation3])
relation_str='{[a]->[ap]: -1a+5=0} union {[a]->[ap]: -1a+6=0} union {[a]->[ap]: -1a+7=0}'
self.failUnless(str(relation)==relation_str,'%s!=%s'%(str(relation),relation_str))
def testRenameWithConstraintRelation(self):
from iegen.ast.visitor import UniqueTupleVarsVisitor
from iegen.ast import PresRelation, VarTuple, Conjunction, Equality, NormExp, VarExp, FuncExp
from iegen.parser import PresParser
rel = PresRelation(
VarTuple([VarExp(1, "a")]),
VarTuple([VarExp(1, "b"), VarExp(1, "a")]),
Conjunction([Equality(NormExp([VarExp(1, "b"), FuncExp(-1, "f", [NormExp([VarExp(1, "a")], 0)])], 0))]),
)
changed = UniqueTupleVarsVisitor().visit(rel).changed
rel_res = PresParser.parse_relation("{[a]->[b,a0]: b=f(a) and a=a0}")
self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel))
self.failUnless(True == changed, "changed!=True")
def testMultipleRenameRelation(self):
from iegen.ast.visitor import UniqueTupleVarsVisitor
from iegen.ast import PresRelation, VarTuple, Conjunction, VarExp
from iegen.parser import PresParser
rel = PresRelation(
VarTuple([VarExp(1, "a"), VarExp(1, "b"), VarExp(1, "c"), VarExp(1, "c")]),
VarTuple([VarExp(1, "d"), VarExp(1, "e"), VarExp(1, "a"), VarExp(1, "d")]),
Conjunction([]),
)
changed = UniqueTupleVarsVisitor().visit(rel).changed
rel_res = PresParser.parse_relation("{[a,b,c,c0]->[d,e,a0,d0]: c=c0 and a=a0 and d=d0}")
self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel))
self.failUnless(True == changed, "changed!=True")
def testIsTupleNoSearchConstraints(self):
from iegen.ast.visitor import IsVarVisitor
from iegen.parser import PresParser
from iegen.ast import Equality, Inequality, NormExp, VarExp
set = PresParser.parse_set("{[]}")
set.conjunct.constraints.append(Equality(NormExp([VarExp(1, "b")], 1)))
set.conjunct.constraints.append(Inequality(NormExp([VarExp(-1, "a")], 10)))
relation = PresParser.parse_relation("{[]->[]}")
relation.conjunct.constraints.append(Equality(NormExp([VarExp(1, "b")], 1)))
relation.conjunct.constraints.append(Inequality(NormExp([VarExp(-1, "a")], 10)))
self.failIf(IsVarVisitor("a").visit(set).is_tuple_var, "'a' is a tuple var in %s" % set)
self.failIf(IsVarVisitor("b").visit(set).is_tuple_var, "'b' is a tuple var in %s" % set)
self.failIf(IsVarVisitor("a").visit(relation).is_tuple_var, "'a' is a tuple var in %s" % relation)
self.failIf(IsVarVisitor("b").visit(relation).is_tuple_var, "'b' is a tuple var in %s" % relation)
def testLikePresRelation(self):
from iegen import Relation
from iegen.ast import VarTuple,Conjunction,Node
from iegen.parser import PresParser
class DummyPresRelation(Node):
def __init__(self):
self.tuple_in=VarTuple([])
self.tuple_out=VarTuple([])
self.conjunct=Conjunction([])
self.symbolics=[]
def arity(self):
return (0,0)
def apply_visitor(self,visitor):
visitor.visitPresRelation(self)
relation=PresParser.parse_relation('{[]->[]}')
Relation(relations=[relation,DummyPresRelation()])
def __init__(self, relation_string=None, symbolics=None, relations=None):
symbolics = [] if symbolics is None else symbolics
if None is not relation_string and None is relations:
# Ensure we are given Symbolic objects
raise_objs_not_like_types(
symbolics,
Symbolic,
"Set construction failure: symbolics must be a collect of objects that look like a Symbolic",
)
self.relations = [PresParser.parse_relation(relation_string, symbolics)]
elif None is not relations and None is relation_string:
if len(symbolics) > 0:
raise ValueError("Cannot specify symbolics when specifying a collection of relations.")
if len(relations) > 0:
self.relations = relations
else:
raise ValueError("Must specify at least one relation in the relations collection")
else:
raise ValueError("Relation.__init__ takes either a relation string or a collection of relations.")
def testNonPresRelationFail(self):
from iegen import Relation
from iegen.parser import PresParser
relation=PresParser.parse_relation('{[]->[]}')
Relation(relations=[relation,"hello!"])
