def generateterms():
term1 = randomterm()
operations.assignvariables(term1)
print term1
term2 = parser.parse(str(term1))
operations.assignvariables(term2)
print term2
print term1 == term2
return (term1, term2)
def generatereductiongraph():
'''
Generate a random beta-reduction graph.
'''
term = randomterm()
operations.assignvariables(term)
term.makestr()
print term
print "----"
g1 = operations.reductiongraph(term)
return g1
def DrawGraph(self, drawing):
try:
Drawer = algorithms[self.algo_combo.GetValue()]
except KeyError:
return
self.drawing.selected = Drawer
self.drawing.ready = True
self.drawing.startnum = 0
self.drawing.endnum = 1000000
term = self.term_input.GetValue()
try:
#self.drawing.term = operations.parse(term.replace(u'\u03bb',"#"))
self.drawing.term = operations.parse(term)
except (ParseException, LambdaParseException):
# The TRS parser throws ParseException when it fails.
self.term_input.SetBackgroundColour(TERM_PARSE_ERROR_COLOUR)
return
self.term_input.SetBackgroundColour("#FFFFFF")
self.drawing.mgs = []
operations.assignvariables(self.drawing.term)
self.drawing.startnumber = 1
try:
def iterator():
Drawer = self.drawing.selected
for (i,g) in enumerate(operations.reductiongraphiter(self.drawing.term, self.drawing.startnum, self.drawing.endnum, self.rule_set)):
yield g
self.drawing.iterator = iterator()
except KeyError:
pass
rg = self.drawing.iterator.next()
g = Drawer(rg)
self.drawing.reductiongraphlist = [rg]
self.drawing.graph = g
self.drawing.graphlist = [g]
self.drawing.graphnumber = 0
self.drawing.nomoregraphs = False
self.drawing.starttobig = False
self.drawing.graph.update_layout_animated(self.drawing.iter_animated)
def randomterm():
'''
Generate a pseude-random DAG-representation of a lambda term.
'''
global freevars
global boundvars
freevars = 0
boundvars = 0
def _node(p, boundlist):
global freevars
global boundvars
r = random.uniform(0, 1)
if r < p['abstraction']:
_lp = p
_lp['variable'] = _lp['variable'] + 0.09
_lp['abstraction'] = _lp['abstraction'] - 0.07
_lp['application'] = _lp['application'] - 0.02
node = lambda_dag.Abstraction()
boundvars = boundvars + 1
b = 'B' + str(boundvars)
node.varname = b
node.add(_node(_lp, boundlist + [b]))
elif r < p['abstraction'] + p['application']:
_lp = copy.deepcopy(p)
_lp['abstraction'] = _lp['abstraction'] + 0.04
_lp['application'] = _lp['application'] - 0.06
_lp['variable'] = _lp['variable'] + 0.02
_rp = copy.deepcopy(p)
_rp['abstraction'] = _rp['abstraction'] + 0.02
_rp['application'] = _rp['application'] - 0.02
_rp['variable'] = _rp['variable']
node = lambda_dag.Application()
node.add(_node(_lp, boundlist))
node.add(_node(_rp, boundlist))
else:
if random.uniform(0,
1) < p['boundvar'] and not len(boundlist) == 0:
name = boundlist[random.randint(0, len(boundlist) - 1)]
else:
freevars = freevars + 1
name = 'F' + str(freevars)
node = lambda_dag.Variable(name)
return node
p = {
'abstraction': 0.6,
'application': 0.4,
'variable': 0.0,
'boundvar': 0.95
}
start = _node(p, [])
operations.assignvariables(start)
start.makestr()
return start
def getgraph(termstr):
term = parser.parse(termstr)
operations.assignvariables(term)
g = operations.reductiongraph(term)
return g
mgs = []
for (i, g) in enumerate(operations.reductiongraphiter(term, 0, 500)):
#if len(g.nodes) <= 5:
# continue
print "Graph no. " + str(i)
mgs.append(MajorizationGraph(g, 1000, 730, 10**-2))
print "Drawing " + str(len(mgs)) + " different graph versions."
gldraw = GlDraw()
gldraw.drawlist(mgs)
def drawit2(term):
def f(term):
for g in operations.reductiongraphiter(term, 0, 100):
# yield KKGraph(g,1000,730)
yield MajorizationGraph(g, 1024, 738, 10**-3)
# yield DotGraph(g)
# yield CircoGraph(g)
# yield FdpGraph(g)
# yield TwopiGraph(g)
# yield NeatoGraph(g)
# yield KKGraph(g)
gldraw = GlDraw(iterable=f(term))
gldraw.drawiter()
if __name__ == "__main__":
term = parser.parse(t)
operations.assignvariables(term)
drawit2(term)