def test_vars_are_bound_or_free_or_constants(self):
t = '''
((or (a ?method_var str_const1) (b ?method_var str_const2)) (c ?method_var ?out_var) (d ?out_var 123.0))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
bound_variables = ['?method_var']
logical_expression.classify_variables(bound_variables=bound_variables, root_node=actual)
# bound_variables argument isn't mutable
self.assertEqual(['?method_var'], bound_variables)
a_node = list(self.world_state_facts(actual, 'a'))[0]
b_node = list(self.world_state_facts(actual, 'b'))[0]
c_node = list(self.world_state_facts(actual, 'c'))[0]
d_node = list(self.world_state_facts(actual, 'd'))[0]
self.assertEqual(set(['?method_var']), set(a_node.bound_variables))
self.assertEqual(set(['str_const1']), set(a_node.constants))
self.assertEqual(set(['?method_var']), set(b_node.bound_variables))
self.assertEqual(set(['str_const2']), set(b_node.constants))
self.assertEqual(set(['?method_var']), set(c_node.bound_variables))
self.assertEqual(set(), set(c_node.constants))
self.assertEqual(set(['?out_var']), set(d_node.bound_variables))
self.assertEqual(set([123.0]), set(d_node.constants))
def test_conversion_with_call_term(self):
t = '''
((or (a) (b)) (call func ?x ?y))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
expected = '(or (and a func) (and b func))'
self.assertEqual(expected, self.tree_to_sexp(actual))
def test_literal_is_dnf(self):
actual = logical_expression.build(s_expression.parse('((a))'))
actual = logical_expression.convert_to_dnf(actual)
expected = node_type.LogicalOp(
op=node_type.OP_OR,
children=[node_type.Atom(name='a')])
self.assertEqual(expected, actual)
actual = logical_expression.build(s_expression.parse('((not (a)))'))
actual = logical_expression.convert_to_dnf(actual)
expected = node_type.LogicalOp(
op=node_type.OP_OR,
children=[node_type.LogicalOp(
op=node_type.OP_NOT,
children=[node_type.Atom(name='a')])])
self.assertEqual(expected, actual)
def test_conversion_5(self):
t = '''
((t1) (or (not (t2)) (and (t2) (t3) (t4))))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
expected = '(or (and t1 (not t2)) (and t1 t2 t3 t4))'
self.assertEqual(expected, self.tree_to_sexp(actual))
def test_conversion_4(self):
t = '''
((or (not (call f1))))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
expected = '(or (not f1))'
self.assertEqual(expected, self.tree_to_sexp(actual))
def test_conversion_2(self):
t = '''
((a) (not (or (b) (c))))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
expected = '(or (and a (not b) (not c)))'
self.assertEqual(expected, self.tree_to_sexp(actual))
def test_conversion_1(self):
t = '''
((and (q1) (or (r1) (r2)) (q2) (or (r3) (r4)) (q3)))
'''
actual = logical_expression.build(s_expression.parse(t))
actual = logical_expression.convert_to_dnf(actual)
expected = '(or (and q1 r1 q2 r3 q3) (and q1 r1 q2 r4 q3) (and q1 r2 q2 r3 q3) (and q1 r2 q2 r4 q3))'
self.assertEqual(expected, self.tree_to_sexp(actual))
def build_branch(name, precondition_expr, tasklist_expr, method_node):
branch = node_type.Branch()
branch.name = lex_token.fixup_name(name)
if match_child(precondition_expr, 0, s_expression.Symbol, lex_token.PERMUTE):
permute_atom_expr = assert_child(precondition_expr, 1, s_expression.List)
branch.permute_atom = build_permute_atom(permute_atom_expr)
precondition_expr.children = precondition_expr.children[2:]
precondition_node = logical_expression.build(precondition_expr)
precondition_node = logical_expression.convert_to_dnf(precondition_node)
logical_expression.classify_variables(method_node.variables, precondition_node)
task_list_nodes = build_task_list(tasklist_expr)
branch.children = [precondition_node] + task_list_nodes
return branch
def build_branch(name, precondition_expr, tasklist_expr, method_node):
branch = node_type.Branch()
branch.name = lex_token.fixup_name(name)
if match_child(precondition_expr, 0, s_expression.Symbol,
lex_token.PERMUTE):
permute_atom_expr = assert_child(precondition_expr, 1,
s_expression.List)
branch.permute_atom = build_permute_atom(permute_atom_expr)
precondition_expr.children = precondition_expr.children[2:]
precondition_node = logical_expression.build(precondition_expr)
precondition_node = logical_expression.convert_to_dnf(precondition_node)
logical_expression.classify_variables(method_node.variables,
precondition_node)
task_list_nodes = build_task_list(tasklist_expr)
branch.children = [precondition_node] + task_list_nodes
return branch
def test_empty_expression_is_dnf(self):
actual = logical_expression.build(s_expression.parse('()'))
actual = logical_expression.convert_to_dnf(actual)
expected = node_type.LogicalOp(op=node_type.OP_OR)
self.assertEqual(expected, actual)
