def extend(self, goals, variables):
"""
Extends the current example by using the fol_bc_ask algorithm to determine
values for the new variables.
@param goals: The goals by which the extension of the example is to be
calculated.
@type goals: A list of Term objects.
@param variables: The new variables in the extension.
@type variables: A list of Var objects.
@return: The number of examples created from extending.
"""
logger.debug("extend( " + str(goals) + ", " + str(variables) + " )")
extension_count = 0
examples_count = 0
for node, bindings in self.enumerate_nodes_bindings():
extended = False
logger.debug("calling " + str(fol_bc_ask) + " with '" + str(goals)
+ "' '" + str(bindings) + "'")
for answer in fol_bc_ask(goals, bindings):
if answer != None:
examples_count += 1
extended = True
value = []
for var in variables:
value.append(answer[var])
node.children.append(ExampleTree.Node(variables, value, node))
if extended:
extension_count += 1
self.levels += 1
self._count_list.append(examples_count)
logger.debug("Performed " + str(extension_count) + " extensions.")
return extension_count
def assertNotFollows(self, arg0, arg1=None):
msg, term = None, None
if isinstance(arg0, str):
msg = arg0
term = arg1
else:
term = arg0
for x in fol_bc_ask([term], {}):
if msg:
self.fail(msg)
else:
self.fail()
def prune_covered(self):
logger.debug("Examples to consider for pruning: ")
logger.debug(str(self._examples))
for ex in self._examples[:]:
prune = False
logger.debug("Calling fol_bc_ask(" + str(self.predicate(*ex.root.values)) + ", {})")
for answer in fol_bc_ask([self.predicate(*ex.root.values)], {}):
logger.debug("fol_bc_ask(" + str(self.predicate(*ex.root.values))
+ ", {}) -> " + str(answer))
if answer != None and answer != False:
self._examples.remove(ex)
prune = True
logger.debug("Pruned '%s'." % ex)
break
if not prune: logger.debug("Did not prune '%s'." % ex)
def determine_param_orderings(predicate):
logger.debug("Determining ordering for: " + str(predicate))
def establish_relationship(value_pair, index_pair, op, cmp_map):
x,y = value_pair
i,k = index_pair
if not(cmp_map.has_key((i,k)) and cmp_map[(i,k)] == None):
if op(x,y):
if cmp_map.has_key((i,k)):
if op != cmp_map[(i,k)]:
cmp_map[(i,k)] = None
else:
cmp_map[(i,k)] = op
elif cmp_map.has_key((i,k)) and op == cmp_map[(i,k)]:
cmp_map[(i,k)] = None
logger.debug(str(cmp_map))
# end establish_relationship
v = UniqueVariableFactory()
type_map = {}
types = predicate.param_types
for i, type in zip(range(0, len(types)), types):
if not type_map.has_key(type):
type_map[type] = []
type_map[type].append(i)
pairs = []
for type in type_map.keys():
for x in choose(type_map[type], 2):
pairs.append(list(x))
cmp_map = {}
variables = v.next_variable_sequence(predicate.arity)
logger.debug("Calling: fol_bc_ask( %s )" % predicate(*variables))
for answer in fol_bc_ask([predicate(*variables)], {}):
logger.debug("Answer: " + str(answer))
for pair in pairs:
i,k = pair
x,y = answer[variables[i]], answer[variables[k]]
logger.debug("Comparing %s and %s." % (x, y))
try:
for op in [operator.lt, operator.gt, operator.eq]:
establish_relationship((x,y), (i,k), op, cmp_map)
except:
pass
return cmp_map
def determine_covered(predicate, tuple):
for x in fol_bc_ask([predicate(*tuple)], {}):
return True
return False
def consult(query):
print str(query)
for answer in fol_bc_ask(query, {}): print "Answer: " + str(answer)