return 1
def __repr__(self):
- return 'Rule(%s, %r)' % (self.index, self.src)
+ return '%3s: %s' % (self.index, self.src)
def render_ctx(self, ctx, indent=''):
# TODO: highlight expression which caused the error.
c = Crux(head=None, rule=self, body=None, vs = ctx)
return '\n'.join(indent + line for line in c.format())
- def debug(self):
- import debug
- with file(dotdynadir / 'tmp.dyna', 'wb') as f:
- f.write(self.src)
- debug.main(f.name)
+# def debug(self):
+# import debug
+# with file(dotdynadir / 'tmp.dyna', 'wb') as f:
+# f.write(self.src)
+# debug.main(f.name)
# TODO: yuck, hopefully temporary measure to support pickling the Interpreter's
Handle popping `item`: fold `item`'s aggregator to get it's new value
(handle errors), propagate changes to the rest of the circuit.
"""
- if item.aggregator is None:
- return item
try:
# compute item's new value
now = item.aggregator.fold()
e.traceback = traceback.format_exc()
errors.append((e, handler))
- if errors:
- self.set_error(item, (None, errors))
- return Error()
+ if hasattr(self, 'was') and self.was:
+ was = self.was
+ if item in was:
+ if item.value != was[item]:
+ item.value = was[item]
- for e in emits:
- self.emit(*e)
+ if errors:
+ e = Error()
+ self.push(item, e, delete=False)
- return self.pop(item)
+ # Force value to error, since aggregator might ignore it. This is
+ # not correct XREF:agg-error
+ self.replace(item, e)
+ self.set_error(item, (None, errors))
+ return e
+ else:
+ for e in emits:
+ self.emit(*e)
+ return self.pop(item)
def load_plan(self, filename):
"""
del self.error[x]
def set_error(self, x, e):
- if not e:
- self.clear_error(x)
self.error[x] = e
#___________________________________________________________________________
head_fn = '%s/%d' % (ys[0], len(ys) - 1)
break
else:
- assert False, 'did not find head'
+ raise AssertionError('Did not find head.')
self.rules[index] = rule = Rule(index)
rule.span = hide_ugly_filename(span)
self.recompute_gbc_memo(head_fn)
else:
- assert False, "Can't add rule with out an initializer or query handler."
+ raise AssertionError("Can't add rule with out an initializer or query handler.")
if True:
args = (index,
self.uninitialized_rules.remove(rule)
else:
+
# Backchained rule --
# remove query handler
self._gbc[rule.head_fn].remove(rule.query)
if not self.rule_by_head[rule.head_fn]:
if rule.head_fn in self.chart:
self.chart[rule.head_fn].set_aggregator(None)
- if rule.head_fn in self.agg_name:
- del self.agg_name[rule.head_fn]
+ #if rule.head_fn in self.agg_name: rule can't exist with out an aggregator
+ del self.agg_name[rule.head_fn]
return self.changed
if visited is None:
visited = set()
- if fn not in self._gbc or fn in visited:
+ if fn not in self.bc or fn in visited:
# don't refresh non-BC computation. Also, be careful not to get
# stuck in an infinite loop if there is a cycle in the dep graph
return
visited.add(fn)
+ # YUCK: find some was to avoid this...
+ self.was = {x: x.value for x in self.chart[fn].intern.values()}
+
+ for x in self.chart[fn].intern.values():
+ x.value = None # avoid memo
+
for x in self.chart[fn].intern.values():
- self.force_gbc(x)
+ now = self.force_gbc(x)
+
+ if now != self.was[x]:
+ self.changed[x] = now
+ else:
+ if x in self.changed:
+ del self.changed[x]
+
+ self.was = None
# recompute dependent BC memos
for v in self.coarse_deps[fn]:
for i in sorted(self.rules):
rule = self.rules[i]
if rule.init is not None and not rule.initialized:
- print '%3s: %s <-- uninitialized' % (i, rule.src)
+ print '%s <-- uninitialized' % rule
else:
- print '%3s: %s' % (i, rule.src)
+ print rule
print
x = eval(name)(*args)
return todyna(x)
+# TODO: should convert Term arguments
def topython(x):
if islist(x):
return [topython(y) for y in x.aslist]
elif isinstance(x, MapsTo):
return tuple(x.args)
- return x
+# elif isinstance(x, Term):
+# z = Term(x.fn, tuple(topython(y) for y in x.args))
+# z.value = topython(x.value)
+# return z
+ else:
+ return x
def todyna(x):
if isinstance(x, (set, Counter)):
else:
return x
-def get(x, i):
- return x[i]
+#def get(x, i):
+# return x[i]
-def getkey(m, k):
- return m[k]
+#def getkey(m, k):
+# return m[k]
-def setkey(m, k, v):
- m[k] = v
- return m
+#def setkey(m, k, v):
+# m[k] = v
+# return m
def islist(x):
return isinstance(x, Cons) or x is Nil
def iter_cons(x):
if not islist(x):
- raise TypeError("Attemping to iterate something which isn't a list. %r" % (x,))
+ raise TypeError("Attempting to iterate something which isn't a list. %r" % (x,))
return x.like_chart()
def in_list(x, a):
if not islist(a):
- raise TypeError("Attemping to iterate something which isn't a list. %r" % (a,))
+ raise TypeError("Attempting to iterate something which isn't a list. %r" % (a,))
return todyna(x in a.aslist)
# should probably be done with memoized backchaining...
| sentence(S) = reverse(s(S, slen(S))).
|
| goal(S) max= phrase(S, "ROOT", 0, length(sentence(S))).
-| parse(S) = path(S, "ROOT", 0, length(sentence(S))).
+| parse(S) := path(S, "ROOT", 0, length(sentence(S))).
*ignore*
-
% very inefficient way to format trees (not required, just fun to see that we
% can do it).
%
%| tostring([X,Y,Z]) := "(" + tostring(X) + " " + tostring(Y) + " " + tostring(Z) + ")".
% collect errors
-%> errors(S) = [tostring(parse(S)), tostring(b(tree(S)))] for parse(S) != b(tree(S)).
+%> errors(S) = parse(S) != b(tree(S)) for tree(S).
+%
% *ignore*
% report accuracy
Changes
=======
-accuracy = 0.9130434782608695.
-correct = 21.0.
+accuracy = 0.9565217391304348.
+correct = 22.0.
ntrees = 23.
-% inspect errors
-%> query errors(S)
+% inspect errors -- can't get null parses.
+
+%> vquery parse(X)
+
+% query errors(X)
%errors(12) = ["(ROOT (S (NP Laura) (VP (VP (V (V say) -s) (SBAR that (S (NP George) (VP (Modal might) (VP (V sleep)))))) (PP (P on) (NP (Det the) (N floor))))) !)", "(ROOT (S (NP Laura) (VP (V (V say) -s) (SBAR that (S (NP George) (VP (VP (Modal might) (VP (V sleep))) (PP (P on) (NP (Det the) (N floor)))))))) !)"].
%errors(21) = ["(ROOT (S (NP (NP (Det the) (N (Adj (Adj fine) (@Adj and (Adj blue))) (N woman))) (@NP and (NP (Det every) (N man)))) (VP (VP (Modal must) (VP (V have) (VP (V (V eat) -ed) (NP (Det two) (N (N sandwich) -s))))) (@VP and (VP (VP (V (V sleep) -ed)) (PP (P on) (NP (Det the) (N floor))))))) .)", "(ROOT (S (NP (NP (Det the) (N (Adj (Adj fine) (@Adj and (Adj blue))) (N woman))) (@NP and (NP (Det every) (N man)))) (VP (VP (Modal must) (VP (V have) (VP (VP (V (V eat) -ed) (NP (Det two) (N (N sandwich) -s))) (@VP and (VP (V (V sleep) -ed)))))) (PP (P on) (NP (Det the) (N floor))))) .)"].
projects / dyna2 / commitdiff