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_)
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_fluent_exists_and(self):
objs = {'x1': 1, 'x2': 2, 'x3': 3, 'x4': 4}
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' = exists_{{?x : obj}}[ q(?x) > 3 ^ 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_, True)
conv.world.step()
p = conv.world.getState(WORLD, 'p', unique=True)
self.assertEqual(p, any(q > 3 and p_ for q in objs.values()))
def test_const_exists_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' = exists_{{?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_if_action_choice(self):
rddl = '''
domain my_test {
pvariables {
p : { state-fluent, int, default = 0 };
q : { state-fluent, int, default = 1 };
a1 : { action-fluent, bool, default = false };
a2 : { action-fluent, bool, default = false };
};
cpfs { p' = if (a1) then
p + 1
else if (a2) then
p - 1
else
9;
};
reward = -p;
}
non-fluents my_test_empty { domain = my_test; }
instance my_test_inst { domain = my_test; init-state { a1; }; horizon = 2; }
'''
conv = Converter(const_as_assert=True)
conv.convert_str(rddl)
p = conv.world.getState(WORLD, 'p', unique=True)
self.assertEqual(p, 0)
conv.world.step()
ag_name = next(iter(conv.world.agents.keys()))
a = conv.world.getFeature(actionKey(ag_name), unique=True)
self.assertEqual(a, conv.actions[ag_name]['a2'])
p = conv.world.getState(WORLD, 'p', unique=True)
self.assertEqual(p, -1)
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_invalid_fluent_forall_if(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}}[ if (q(?x) > 2) then true else 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})={v}' for o, v in objs.items())};
}};
}}
'''
conv = Converter()
with self.assertRaises(ValueError):
conv.convert_str(rddl)
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_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_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_single_agent(self):
rddl = '''
domain my_test {
pvariables { a : { action-fluent, bool, default = false }; };
cpfs { };
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)
self.assertEqual(len(conv.world.agents), 1)
def pre_replay(self, logger=logging):
# Create PsychSim model
logger.info('Creating world')
try:
self.parser.startProcessing(self.derived_features, self.msg_types)
except:
logger.error('Unable to start parser')
logger.error(traceback.format_exc())
return False
if self.feature_output:
# processes data to extract features depending on type of count
features = {'File': os.path.splitext(os.path.basename(self.file_name))[0]}
if self.condition_fields is None:
self.condition_fields = list(filename_to_condition(features['File']).keys())
for feature in self.derived_features:
features.update(_get_feature_values(feature))
self.feature_data.append(features)
try:
if self.rddl_file:
# Team mission
self.rddl_converter = Converter()
self.rddl_converter.convert_file(self.rddl_file)
self.world = self.rddl_converter.world
players = set(self.parser.agentToPlayer.keys())
zero_models = {name: self.world.agents[name].zero_level() for name in players}
for name in players:
agent = self.world.agents[name]
agent.create_belief_state()
agent.create_belief_state(model=zero_models[name])
agent.setAttribute('selection', 'distribution', zero_models[name])
for other_name in players-{name}:
other_agent = self.world.agents[other_name]
self.world.setModel(name, zero_models[name], other_name, other_agent.get_true_model())
agent.set_observations()
else:
# Solo mission
self.world, self.triage_agent, _, self.victims, self.world_map = \
make_single_player_world(self.parser.player_name(), self.map_table.init_loc,
self.map_table.adjacency, self.map_table.victims, False, True,
False, logger.getChild('make_single_player_world'))
except:
logger.error('Unable to create world')
exc_type, exc_value, exc_traceback = sys.exc_info()
logger.error(traceback.format_exc())
return False
return True
