def test_if_nested_bool(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = -1 }; q : { state-fluent, bool, default = false }; r : { state-fluent, bool, default = true }; s : { state-fluent, bool, default = false }; a : { action-fluent, bool, default = false }; }; cpfs { p' = if (~q ^ r) then if (s | (p < 0)) then 2 * p else 0 else -1; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) r = conv.world.getState(WORLD, 'r', unique=True) s = conv.world.getState(WORLD, 's', unique=True) self.assertEqual(_p, -1) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) if not q and r: if s or (p < 0): p_ = 2 * _p else: p_ = 0 else: p_ = -1 self.assertEqual(p, p_)
def test_invalid_fluent_prod(self): objs = {'x1': 1, 'x2': 2, 'x3': 3, 'x4': 4} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ p : {{ state-fluent, int, default = -1 }}; q(obj) : {{ state-fluent, int, default = -1 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = prod_{{?x : obj}}[q(?x)]; }}; reward = 0; }} non-fluents my_test_nf {{ domain = my_test; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ {'; '.join(f'q({o})={v}' for o, v in objs.items())}; }}; }} ''' conv = Converter() with self.assertRaises(AssertionError): conv.convert_str(rddl)
def test_const_forall_false(self): objs = {'x1': False, 'x2': False, 'x3': False, 'x4': False} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ p : {{ state-fluent, bool, default = true }}; q(obj) : {{ state-fluent, int, default = -1 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = forall_{{?x : obj}}[ false ]; }}; reward = 0; }} non-fluents my_test_nf {{ domain = my_test; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ {'; '.join(f'q({o})={str(v).lower()}' for o, v in objs.items())}; }}; }} ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, True) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, False)
def test_non_agent_fluent(self): agents = ['John', 'Paul', 'George', 'Ringo'] rddl = f''' domain my_test {{ types {{ agent : object; }}; pvariables {{ p : {{ state-fluent, int, default = 0 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = p + 1; }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; objects {{ agent : {{ {",".join(agents)} }}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 0) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 1)
def test_fluent(self): agents = {'John': 1.22, 'Paul': 3.75, 'George': -1.14, 'Ringo': 4.73} rddl = f''' domain my_test {{ types {{ agent : object; }}; pvariables {{ p(agent) : {{ state-fluent, real, default = 0 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p'(?a) = p(?a) + 1; }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; objects {{ agent : {{ {", ".join(agents.keys())} }}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ {'; '.join(f'p({a}) = {v}' for a, v in agents.items())}; }}; }} ''' conv = Converter() conv.convert_str(rddl) for a, v in agents.items(): p = conv.world.getState(a, 'p', unique=True) self.assertEqual(p, v) conv.world.step() for a, v in agents.items(): p = conv.world.getState(a, 'p', unique=True) self.assertEqual(p, v + 1)
def test_normal_params(self): num_bins = 10 stds = 4 rddl = f''' domain my_test {{ pvariables {{ p : {{ state-fluent, real, default = 0 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = Normal(0, 1); }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter(normal_bins=num_bins, normal_stds=stds) conv.convert_str(rddl) p_ = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p_, 0) conv.world.step() p = conv.world.getState(WORLD, 'p') import numpy as np bins = np.array(conv._normal_bins) for k, v in zip(bins, conv._normal_probs): self.assertEqual(p[k], v)
def test_poisson_params(self): num_bins = 10 stds = 4 expected_rate = 25 mean = 20 rddl = f''' domain my_test {{ requirements {{ normal_bins{num_bins}, normal_stds{stds}, poisson_exp_rate{expected_rate} }}; pvariables {{ p : {{ state-fluent, real, default = {mean} }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = Poisson(p); }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, mean) conv.world.step() p = conv.world.getState(WORLD, 'p') import numpy as np bins = np.array(conv._normal_bins) * np.sqrt( conv._poisson_exp_rate) + mean for k, v in zip(bins, conv._normal_probs): self.assertEqual(p[k], v)
def test_if_action(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = 0 }; q : { state-fluent, int, default = -3 }; r : { state-fluent, int, default = 4 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = if (a) then q else r; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) r = conv.world.getState(WORLD, 'r', unique=True) self.assertEqual(p, 0) self.assertEqual(q, -3) self.assertEqual(r, 4) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, q)
def test_object_fluent_def(self): rddl = ''' domain my_test { types { obj_level: object; }; pvariables { p : { state-fluent, obj_level, default = none }; a : { action-fluent, bool, default = false }; }; cpfs { p' = p; }; reward = 0; } non-fluents my_test_empty { domain = my_test; objects { obj_level : {low, medium, high}; }; } instance my_test_inst { domain = my_test; init-state { p=low; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'low') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'low')
def test_switch_case_if(self): rddl = ''' domain my_test { types { enum_level : {@low, @medium, @high}; }; pvariables { p : { state-fluent, enum_level, default = @low }; q : { state-fluent, enum_level, default = @low }; a : { action-fluent, bool, default = false }; }; cpfs { p' = switch (q) { case @low : if(p==@medium) then @high else @low, case @medium : if(p==@low) then @medium else @high, default : if(p==@high) then @low else @medium }; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(_p, 'low') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) self.assertEqual(p, _python_switch(q, {'low': 'high' if p == 'medium' else 'low', 'medium': 'medium' if p == 'low' else 'high', 'default': 'low' if p == 'high' else 'medium'}))
def test_if_switch_enum(self): rddl = ''' domain my_test { types { enum_level : {@low, @medium, @high}; }; pvariables { p : { state-fluent, enum_level, default = @low }; q : { state-fluent, enum_level, default = @low }; a : { action-fluent, bool, default = false }; }; cpfs { p' = if (switch (q) { case @low : true, case @medium : true, default : false }) then @high else @low; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(_p, 'low') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) self.assertEqual(p, 'high' if _python_switch(q, {'low': True, 'medium': True, 'default': False}) else 'low')
def test_switch_case_op(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = 0 }; q : { state-fluent, int, default = 1 }; r : { state-fluent, int, default = 2 }; s : { state-fluent, int, default = 3 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = switch (p) { case 2 * q - r : q, case r : r, case s : s, default: 4 }; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(_p, 0) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) r = conv.world.getState(WORLD, 'r', unique=True) s = conv.world.getState(WORLD, 's', unique=True) self.assertEqual(p, _python_switch(_p, {2 * q - r: q, r: r, s: s, 'default': 4}))
def test_switch_consts(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = 0 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = switch (p) { case 1 : 1, case 2 : 2, case 3 : 3, default: 4 }; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(_p, 0) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, _python_switch(_p, {1: 1, 2: 2, 3: 3, 'default': 4}))
def test_switch_nested_if(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = 1 }; q : { state-fluent, int, default = 1 }; r : { state-fluent, int, default = 4 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = switch (p) { case q : if (q > r) then q else r, case r: r, default: 4 }; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) _p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(_p, 1) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) r = conv.world.getState(WORLD, 'r', unique=True) self.assertEqual(p, _python_switch(_p, {q: q if (q > r) else r, r: r, 'default': 4}))
def test_discrete_enum_invalid_non_const(self): rddl = ''' domain my_test { types { enum_level : {@low, @medium, @high}; }; pvariables { p : { state-fluent, enum_level, default = @low }; a : { action-fluent, bool, default = false }; }; cpfs { p' = Discrete(enum_level, @low : if (p >= 2) then 0.5 else 0.2, @medium : if (p >= 2) then 0.2 else 0.5, @high : 0.3 ); }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() with self.assertRaises(AssertionError): conv.convert_str(rddl)
def test_object_fluent_dyn_const_param_var(self): rddl = ''' domain my_test { types { obj_level: object; }; pvariables { p : { state-fluent, obj_level, default = none }; NEXT(obj_level) : { non-fluent, obj_level, default = none }; a : { action-fluent, bool, default = false }; }; cpfs { p' = NEXT(p); }; reward = 0; } non-fluents my_test_empty { domain = my_test; objects { obj_level : {low, medium, high}; }; non-fluents { NEXT(low)=medium; NEXT(medium)=high; NEXT(high)=high; }; } instance my_test_inst { domain = my_test; init-state { p=medium; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'medium') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'high')
def test_normal_var(self): mean = 3 std = 1.5 rddl = f''' domain my_test {{ pvariables {{ p : {{ state-fluent, real, default = {mean} }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = Normal(p, p+{std}); }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) p_ = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p_, mean) conv.world.step() p = conv.world.getState(WORLD, 'p') import numpy as np bins = np.array(conv._normal_bins) * (std + p_) + mean for k, v in zip(bins, conv._normal_probs): self.assertEqual(p[k], v)
def test_object_fluent_dyn_const_multi_param_var(self): rddl = ''' domain my_test { types { obj_level: object; }; pvariables { p : { state-fluent, obj_level, default = none }; q : { state-fluent, obj_level, default = none }; r : { state-fluent, obj_level, default = none }; XOR(obj_level, obj_level) : { non-fluent, obj_level, default = none }; a : { action-fluent, bool, default = false }; }; cpfs { p' = XOR(q, r); }; reward = 0; } non-fluents my_test_empty { domain = my_test; objects { obj_level : {t, f}; }; non-fluents { XOR(t,t)=f; XOR(t,f)=t; XOR(f,t)=t; XOR(f,f)=f; }; } instance my_test_inst { domain = my_test; init-state { p=f; q=f; r=t; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'f') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 't')
def test_poisson_var(self): mean = 10 rddl = f''' domain my_test {{ pvariables {{ p : {{ state-fluent, real, default = 0 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = Poisson( p * 2 + {mean}); }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 0) conv.world.step() p = conv.world.getState(WORLD, 'p') import numpy as np bins = np.array(conv._normal_bins) * np.sqrt( conv._poisson_exp_rate) + mean for k, v in zip(bins, conv._normal_probs): self.assertEqual(p[k], v)
def test_partial_observability(self): rddl = ''' domain my_test { requirements = { partially-observed }; pvariables { p : { state-fluent, int, default = 1 }; q : { observ-fluent, int }; a : { action-fluent, bool, default = false }; }; cpfs { q' = 3; p' = q + 1; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) agent = next(iter(conv.world.agents.values())) self.assertNotIn(stateKey(WORLD, '__p'), agent.omega) self.assertIn(stateKey(WORLD, 'q'), agent.omega) p = conv.world.getState(WORLD, '__p', unique=True) self.assertEqual(p, 1) conv.world.step() conv.world.step() p = conv.world.getState(WORLD, '__p', unique=True) self.assertEqual(p, 4) q = conv.world.getState(WORLD, 'q', unique=True) self.assertEqual(q, 3)
def test_discrete(self): rddl = ''' domain my_test { types { enum_level : {@low, @medium, @high}; }; pvariables { p : { state-fluent, enum_level, default = @low }; q : { state-fluent, int, default = 3 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = if (q >= 2) then Discrete(enum_level, @low : 0.5, @medium : 0.2, @high : 0.3) else Discrete(enum_level, @low : 0.2, @medium : 0.5, @high : 0.3); }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'low') conv.world.step() p = conv.world.getState(WORLD, 'p') self.assertEqual(p['low'], 0.5) self.assertEqual(p['medium'], 0.2) self.assertEqual(p['high'], 0.3)
def test_fluent_param_def(self): objs = {'x1': True, 'x2': False, 'x3': False, 'x4': True} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ p(obj) : {{ state-fluent, bool, default = true }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p'(?o) = false; }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) for o, v in objs.items(): p = conv.world.getState(WORLD, Converter.get_feature_name(('p', o)), unique=True) self.assertEqual(p, True) conv.world.step() for o, v in objs.items(): p = conv.world.getState(WORLD, Converter.get_feature_name(('p', o)), unique=True) self.assertEqual(p, False)
def test_non_fluent(self): agents = {'John': 1.22, 'Paul': 3.75, 'George': -1.14, 'Ringo': 4.73} rddl = f''' domain my_test {{ types {{ agent : object; }}; pvariables {{ C(agent) : {{ non-fluent, real, default = 1}}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; non-fluents {{ {'; '.join(f'C({a}) = {v}' for a, v in agents.items())}; }}; objects {{ agent : {{ {", ".join(agents.keys())} }}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) for a, v in agents.items(): self.assertIn(Converter.get_feature_name(('C', a)), conv.constants) self.assertEqual( conv.constants[Converter.get_feature_name(('C', a))], v)
def test_non_fluent_param_init(self): objs = {'x1': 1, 'x2': 2, 'x3': 3, 'x4': 4} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ C(obj) : {{ non-fluent, int, default = -1}}; p : {{ state-fluent, int, default = 1 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = p + 1; }}; reward = 0; }} non-fluents my_test_nf {{ domain = my_test; non-fluents {{ {'; '.join(f'C({o})={v}' for o, v in objs.items())}; }}; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) for o, v in objs.items(): self.assertIn(Converter.get_feature_name(('C', o)), conv.constants) self.assertEqual( conv.constants[Converter.get_feature_name(('C', o))], v)
def test_action(self): agents = ['John', 'Paul', 'George', 'Ringo'] rddl = f''' domain my_test {{ types {{ agent : object; }}; pvariables {{ p: {{ state-fluent, int, default = 0 }}; a(agent) : {{ action-fluent, bool, default = false }}; }}; cpfs {{ }}; reward = 0; }} non-fluents my_test_empty {{ domain = my_test; objects {{ agent : {{ {",".join(agents)} }}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ p = 1; }}; }} ''' conv = Converter() conv.convert_str(rddl) for ag_name in agents: actions = set(map(str, conv.world.agents[ag_name].actions)) self.assertEqual(len(actions), 1) self.assertIn(f'{ag_name}-a', actions)
def test_enum_fluent_dyn_const_multi_param_var_const(self): rddl = ''' domain my_test { types { enum_level : {@t, @f}; }; pvariables { p : { state-fluent, enum_level, default = @t }; q : { state-fluent, enum_level, default = @f }; XOR(enum_level, enum_level) : { non-fluent, enum_level, default = @f }; a : { action-fluent, bool, default = false }; }; cpfs { p' = XOR(q, @f); }; reward = 0; } non-fluents my_test_empty { domain = my_test; non-fluents { XOR(@t,@t)=@f; XOR(@t,@f)=@t; XOR(@f,@t)=@t; XOR(@f,@f)=@f; }; } instance my_test_inst { domain = my_test; init-state { p=@f; q=@t; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'f') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 't')
def test_const_prod(self): objs = {'x1': 1, 'x2': 2, 'x3': 3, 'x4': 4} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ C(obj) : {{ non-fluent, int, default = -1}}; p : {{ state-fluent, int, default = -1 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = prod_{{?x : obj}}[2]; }}; reward = 0; }} non-fluents my_test_nf {{ domain = my_test; non-fluents {{ {'; '.join(f'C({o})={v}' for o, v in objs.items())}; }}; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ a; }}; }} ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, -1) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, np.power(2, len(objs)))
def test_enum_fluent_dyn_var_param_var(self): rddl = ''' domain my_test { types { enum_level : {@low, @medium, @high}; }; pvariables { p : { state-fluent, enum_level, default = @low }; q(enum_level) : { state-fluent, enum_level, default = @low }; a : { action-fluent, bool, default = false }; }; cpfs { p' = q(p); }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { q(@low)=@medium; q(@medium)=@high; q(@high)=@high; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'low') conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, 'medium')
def test_fluent_forall_or(self): objs = {'x1': 1, 'x2': 2, 'x3': 3, 'x4': 4} rddl = f''' domain my_test {{ types {{ obj : object; }}; pvariables {{ p : {{ state-fluent, bool, default = false }}; q(obj) : {{ state-fluent, int, default = -1 }}; a : {{ action-fluent, bool, default = false }}; }}; cpfs {{ p' = forall_{{?x : obj}}[ q(?x) >= 1 | p ]; }}; reward = 0; }} non-fluents my_test_nf {{ domain = my_test; objects {{ obj : {{{', '.join(objs.keys())}}}; }}; }} instance my_test_inst {{ domain = my_test; init-state {{ {'; '.join(f'q({o})={v}' for o, v in objs.items())}; }}; }} ''' conv = Converter() conv.convert_str(rddl) p_ = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p_, False) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) self.assertEqual(p, all(q >= 1 or p_ for q in objs.values()))
def test_if_nested_rel(self): rddl = ''' domain my_test { pvariables { p : { state-fluent, int, default = -1 }; q : { state-fluent, int, default = 5 }; r : { state-fluent, int, default = 4 }; s : { state-fluent, int, default = 6 }; a : { action-fluent, bool, default = false }; }; cpfs { p' = if (q > r) then if (q > s) then q else 0 else -1; }; reward = 0; } non-fluents my_test_empty { domain = my_test; } instance my_test_inst { domain = my_test; init-state { a; }; } ''' conv = Converter() conv.convert_str(rddl) p = conv.world.getState(WORLD, 'p', unique=True) q = conv.world.getState(WORLD, 'q', unique=True) r = conv.world.getState(WORLD, 'r', unique=True) s = conv.world.getState(WORLD, 's', unique=True) self.assertEqual(p, -1) conv.world.step() p = conv.world.getState(WORLD, 'p', unique=True) if q > r: if q > s: p_ = q else: p_ = 0 else: p_ = -1 self.assertEqual(p, p_)