def test_predicate_extensions():
lang = tarski.language()
pred = lang.predicate('pred', lang.Object, lang.Object)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
model = Model(lang)
with pytest.raises(errors.ArityMismatch):
# This should raise an error, as the predicate is binary
model.add(pred)
with pytest.raises(ValueError):
# This should raise an error, as the predicate sort does not coincide with the sort of the parameters
model.add(pred, 1, 2)
model.add(pred, o1, o2)
assert not model.holds(pred, (o2, o1)) # Make sure the order in which the elements were added is respected!
assert model.holds(pred, (o1, o2))
with pytest.raises(KeyError):
# This should raise an error, as the tuple does not belong to the predicate's extension
model.remove(pred, o2, o1)
model.remove(pred, o1, o2)
with pytest.raises(KeyError):
# This should raise an error, as the tuple has been removed
model.remove(pred, o1, o2)
def test_resource_lock_creation():
with pytest.raises(temporal.NDLSyntaxError):
req = temporal.ResourceLock(**{
"ts": 0.0,
"td": 1.0,
"r": None
})
L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC])
sensor_sort = L.sort('sensor')
camera, range, bearing = [L.constant(name, sensor_sort) for name in ('camera', 'range', 'bearing')]
int_t = L.Integer
engaged = L.function('engaged', sensor_sort, int_t)
req_1 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(camera)
})
req_2 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(range)
})
req_3 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(bearing)
})
def test_model_list_extensions():
lang = tarski.language(theories=[])
p = lang.predicate('p', lang.Object, lang.Object)
f = lang.function('f', lang.Object, lang.Object)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
model = Model(lang)
model.evaluator = evaluate
model.set(f, o1, o2)
model.add(p, o1, o2)
extensions = model.list_all_extensions()
ext_f = extensions[f.signature]
ext_p = extensions[p.signature]
# We want to test that the `list_all_extensions` method correctly unwraps all TermReferences in the internal
# representation of the model and returns _only_ actual Tarski terms. Testing this is a bit involved, as of
# course we cannot just check for (o1, o2) in ext_f, because that will trigger the wrong __eq__ and __hash__
# methods - in other words, to test this we precisely need to wrap things back into TermReferences, so that we can
# compare them properly
assert len(ext_f) == 1 and len(ext_p) == 1
p, v = ext_f[0]
assert TermReference(p) == TermReference(o1) and TermReference(v) == TermReference(o2)
v1, v2 = ext_p[0]
assert TermReference(v1) == TermReference(o1) and TermReference(v2) == TermReference(o2)
def test_matrix_evaluation_case_1():
from tarski.syntax.arithmetic import one
lang = tarski.language('double_integrator',
[Theory.EQUALITY, Theory.ARITHMETIC])
I = lang.matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], lang.Real)
x0 = Model(lang)
x0.evaluator = evaluate
assert x0[I][0, 0].is_syntactically_equal(one(lang.Real))
def test_matrices_constants():
lang = tsk.language('test', [Theory.EQUALITY, Theory.ARITHMETIC])
A = lang.matrix([[0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
lang.Real)
assert isinstance(A, Matrix)
N, M = A.shape
for i in range(N):
for j in range(M):
assert isinstance(A.matrix[i, j], Term)
def test_zero_ary_predicate_set():
L = tarski.language()
P = L.predicate('P')
M = Model(L)
M.add(P)
assert evaluate(P(), M) is True
def create_small_world():
lang = tsk.language("TarskiWorld", theories=[Theory.EQUALITY])
lang.Cube = lang.predicate('Cube', lang.Object)
lang.Tet = lang.predicate('Tet', lang.Object)
lang.LeftOf = lang.predicate('LeftOf', lang.Object, lang.Object)
lang.Dodec = lang.predicate('Dodec', lang.Object)
lang.BackOf = lang.predicate('BackOf', lang.Object, lang.Object)
return lang
def test_resource_level_creation():
L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC])
platform_t = L.sort('platform')
rov1 = L.constant('rov1', platform_t)
int_t = L.Integer
direction = L.function('direction', platform_t, int_t)
req_1 = temporal.ResourceLevel(**{
"ts": 0.0, "td": 20.0, "r": direction(rov1), "n": L.constant(0, int_t)
})
def test_term_refs():
lang = tsk.language()
_ = lang.function('f', lang.Object, lang.Integer)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
tr1 = symref(o1)
tr2 = symref(o1)
tr3 = symref(o2)
assert tr1 == tr2
assert tr1 != tr3
def test_term_refs_compound():
lang = tsk.language()
f = lang.function('f', lang.Object, lang.Integer)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
_ = lang.get('f')
t1 = f(o1)
t2 = f(o1)
t3 = f(o2)
assert t1.symbol == t2.symbol
tr1 = symref(t1)
tr2 = symref(t2)
tr3 = symref(t3)
assert tr1 == tr2
assert tr1 != tr3
def test_predicate_without_equality():
lang = tarski.language(theories=[])
leq = lang.predicate('leq', lang.Integer, lang.Integer)
f = lang.function('f', lang.Object, lang.Integer)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
model = Model(lang)
model.evaluator = evaluate
model.set(f, o1, 1)
model.set(f, o2, 2)
for x in range(0, 5):
for y in range(x, 5):
model.add(leq, x, y)
assert model[leq(f(o1), f(o2))] is True
assert model[leq(f(o2), f(o1))] is False
def test_action_creation():
L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC])
int_t = L.Integer
platform_t = L.sort('platform')
rov1 = L.constant('rov1', platform_t)
direction = L.function('direction', platform_t, int_t)
sensor_sort = L.sort('sensor')
camera, range, bearing = [
L.constant(name, sensor_sort)
for name in ('camera', 'range', 'bearing')
]
engaged = L.function('engaged', sensor_sort, int_t)
region_t = L.sort('region')
p0 = L.constant('p0', region_t)
position = L.predicate('position', platform_t, region_t)
observed = L.predicate('observed', region_t)
req_1 = temporal.ResourceLock(**{
"ts": 0.0,
"td": 10.0,
"r": engaged(camera)
})
req_2 = temporal.ResourceLevel(**{
"ts": 0.0,
"td": 20.0,
"r": direction(rov1),
"n": L.constant(0, int_t)
})
act = temporal.Action(name='observe_poi',
precondition=position(rov1, p0),
requirements=[req_1, req_2],
effects=[(21.0, observed(p0))])
assert len(act.locks) == 1
assert len(act.levels) == 1
assert len(act.effects) == 1
def test_matrix_evaluation_case_2():
lang = tarski.language('double_integrator',
[Theory.EQUALITY, Theory.ARITHMETIC])
I = lang.matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], lang.Real)
x = lang.function('x', lang.Real)
y = lang.function('y', lang.Real)
z = lang.function('z', lang.Real)
v = lang.vector([x(), y(), z()], lang.Real)
x0 = Model(lang)
x0.evaluator = evaluate
x0.setx(x(), 1.0)
x0.setx(y(), 2.0)
x0.setx(z(), 3.0)
# print(x0[I @ v][2, 0])
assert x0[I @ v][2,
0].is_syntactically_equal(lang.constant(3.0, lang.Real))
def test_model_as_atoms():
lang = tarski.language(theories=[])
p = lang.predicate('p', lang.Object, lang.Object)
f = lang.function('f', lang.Object, lang.Object)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
model = Model(lang)
model.evaluator = evaluate
model.set(f, o1, o2)
model.add(p, o1, o2)
atoms = model.as_atoms()
patom, fatom = atoms
assert patom.is_syntactically_equal(p(o1, o2))
term, value = fatom
assert term.is_syntactically_equal(
f(o1)) and value.is_syntactically_equal(o2)
def test_predicate_without_equality_reals():
import numpy
lang = tarski.language(theories=[])
leq = lang.predicate('leq', lang.Real, lang.Real)
w = lang.function('w', lang.Object, lang.Real)
o1 = lang.constant("o1", lang.Object)
o2 = lang.constant("o2", lang.Object)
model = Model(lang)
model.evaluator = evaluate
model.setx(w(o1), 1.0)
model.setx(w(o2), 2.0)
for x in numpy.arange(0.0, 5.0):
for y in numpy.arange(x, 5.0):
model.add(leq, x, y)
assert model[leq(w(o1), w(o2))] is True
assert model[leq(w(o2), w(o1))] is False
def test_ite():
lang = tarski.language('arith', [Theory.EQUALITY, Theory.ARITHMETIC])
c = lang.constant(1, lang.Integer)
x = lang.function('x', lang.Integer)
y = lang.function('y', lang.Integer)
phi = (x() <= y()) & (y() <= x())
t1 = x() + 2
t2 = y() + 3
tau = ite(phi, t1, t2)
model = Model(lang)
model.evaluator = evaluate
model.setx(x(), 1)
model.setx(y(), 2)
assert model[tau].symbol == 5
def test_rddl_model_with_random_vars():
lang = tarski.language(
'lqg_nav_1d',
[Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM])
the_task = Task(lang, 'lqg_nav_1d', 'instance_001')
the_task.requirements = [
rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET
]
the_task.parameters.discount = 1.0
the_task.parameters.horizon = 10
the_task.parameters.max_nondef_actions = 1
# variables
x = lang.function('x', lang.Real)
v = lang.function('v', lang.Real)
u = lang.function('u', lang.Real)
t = lang.function('t', lang.Real)
# non fluents
dt = lang.function('dt', lang.Real)
gx = lang.function('gx', lang.Real)
# Perturbation distribution parameters
mu_w = lang.function('mu_w', lang.Real)
sigma_w = lang.function('sigma_w', lang.Real)
# cpfs
the_task.add_cpfs(t(), t() + dt())
the_task.add_cpfs(v(), v() + dt() * u() + normal(mu_w(), sigma_w()))
the_task.add_cpfs(x(), x() + dt() * v())
# constraints
the_task.add_constraint((u() >= -1.0) & (u() <= 1.0),
rddl.ConstraintType.ACTION)
the_task.add_constraint((v() >= -5.0) & (v() <= 5.0),
rddl.ConstraintType.STATE)
the_task.add_constraint((x() >= -100.0) & (x() <= 100.0),
rddl.ConstraintType.STATE)
# cost function
Q = (x() - gx()) * (x() - gx())
# MRJ: RDDL does not support the abs() algebraic construct
R = ite(
abs(x() - gx()) > 0.0,
u() * u() * 0.01, lang.constant(0.0, lang.Real))
# R = u() * u() * 0.01
the_task.reward = Q + R
# definitions
the_task.x0.set(x(), 0.0)
the_task.x0.set(v(), 0.0)
the_task.x0.set(u(), 0.0)
the_task.x0.set(t(), 0.0)
the_task.x0.set(dt(), 0.5)
the_task.x0.set(gx(), 20.0)
the_task.x0.set(mu_w(), 0.0)
the_task.x0.set(sigma_w(), 0.05)
# fluent metadata
the_task.declare_state_fluent(x(), 0.0)
the_task.declare_state_fluent(t(), 0.0)
the_task.declare_interm_fluent(v(), 1)
the_task.declare_action_fluent(u(), 0.0)
the_task.declare_non_fluent(dt(), 0.0)
the_task.declare_non_fluent(gx(), 0.0)
the_task.declare_non_fluent(mu_w(), 0.0)
the_task.declare_non_fluent(sigma_w(), 0.0)
the_writer = rddl.Writer(the_task)
rddl_filename = os.path.join(tempfile.gettempdir(), 'lqg_nav_1d_001.rddl')
the_writer.write_model(rddl_filename)
mr_reader = rddl.Reader(rddl_filename)
assert mr_reader.rddl_model is not None
assert mr_reader.rddl_model.domain.name == 'lqg_nav_1d'
mr_reader.translate_rddl_model()
assert mr_reader.language is not None
def test_parametrized_model_with_random_vars_and_waypoints_boolean():
lang = tarski.language(
'lqg_nav_2d_multi_unit_bool_waypoints',
[Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM])
the_task = Task(lang, 'lqg_nav_2d_multi_unit_bool_waypoints',
'instance_001')
the_task.requirements = [
rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET
]
the_task.parameters.discount = 1.0
the_task.parameters.horizon = 40
the_task.parameters.max_nondef_actions = 2
vehicle = lang.sort('vehicle', lang.Object)
waypoint = lang.sort('waypoint', lang.Object)
# variables
x = lang.function('x', vehicle, lang.Real)
y = lang.function('y', vehicle, lang.Real)
wx = lang.function('wx', waypoint, lang.Real)
wy = lang.function('wy', waypoint, lang.Real)
vx = lang.function('vx', vehicle, lang.Real)
vy = lang.function('vy', vehicle, lang.Real)
ux = lang.function('ux', vehicle, lang.Real)
uy = lang.function('uy', vehicle, lang.Real)
t = lang.function('t', lang.Real)
wv = lang.predicate('visited', waypoint)
# objects
v001 = lang.constant('v001', vehicle)
p1 = lang.constant('p1', waypoint)
p2 = lang.constant('p2', waypoint)
p3 = lang.constant('p3', waypoint)
# non fluents
dt = lang.function('dt', lang.Real)
wr = lang.function('waypoint_radius', lang.Real)
# Perturbation distribution parameters
mu_w = lang.function('mu_w', lang.Real)
sigma_w = lang.function('sigma_w', lang.Real)
# logical variable
v = lang.variable('v', vehicle)
wpt = lang.variable('wpt', waypoint)
# cpfs
the_task.add_cpfs(t(), t() + dt())
dist_vec_norm = ((x(v) - wx(wpt)) * (x(v) - wx(wpt))) + ((y(v) - wy(wpt)) *
(y(v) - wy(wpt)))
the_task.add_cpfs(wv(wpt), (wv(wpt) | (sqrt(dist_vec_norm) <= wr())))
the_task.add_cpfs(vx(v), vx(v) + dt() * ux(v) + normal(mu_w(), sigma_w()))
the_task.add_cpfs(vy(v), vy(v) + dt() * uy(v) + normal(mu_w(), sigma_w()))
the_task.add_cpfs(x(v), x(v) + dt() * vx(v))
the_task.add_cpfs(y(v), y(v) + dt() * vy(v))
# constraints
the_task.add_constraint(
forall(v, (ux(v) >= -1.0) & (ux(v) <= 1.0) & (uy(v) >= -1.0) &
(uy(v) <= 1.0)), rddl.ConstraintType.ACTION)
the_task.add_constraint(
forall(v, (sqrt(vx(v) * vx(v) + vy(v) * vy(v)) <= 5.0)),
rddl.ConstraintType.STATE)
the_task.add_constraint(forall(v, (x(v) >= -100.0) & (x(v) <= 100.0)),
rddl.ConstraintType.STATE)
the_task.add_constraint(forall(v, (y(v) >= -100.0) & (y(v) <= 100.0)),
rddl.ConstraintType.STATE)
# cost function
WV = sumterm(
wpt,
ite(wv(wpt), lang.constant(1.0, lang.Real),
lang.constant(0.0, lang.Real)))
# MRJ: RDDL does not support the abs() algebraic construct
R = sumterm(v, (ux(v) * ux(v) * 0.01) + (uy(v) * uy(v) * 0.01))
# R = u() * u() * 0.01
the_task.reward = WV - R
# definitions
the_task.x0.set(x(v001), 0.0)
the_task.x0.set(y(v001), 0.0)
the_task.x0.set(vx(v001), 0.0)
the_task.x0.set(vy(v001), 0.0)
the_task.x0.set(ux(v001), 0.0)
the_task.x0.set(uy(v001), 0.0)
the_task.x0.set(wx(p1), 1.0)
the_task.x0.set(wy(p1), -1.0)
the_task.x0.set(wx(p2), 1.0)
the_task.x0.set(wy(p2), 1.0)
the_task.x0.set(wx(p3), 2.0)
the_task.x0.set(wy(p3), 1.0)
the_task.x0.set(t(), 0.0)
the_task.x0.set(dt(), 0.5)
the_task.x0.set(mu_w(), 0.0)
the_task.x0.set(sigma_w(), 0.05)
the_task.x0.set(wr(), 2.0)
# fluent metadata
the_task.declare_state_fluent(x(v), 0.0)
the_task.declare_state_fluent(y(v), 0.0)
the_task.declare_state_fluent(t(), 0.0)
the_task.declare_state_fluent(wv(wpt), False)
the_task.declare_interm_fluent(vx(v), 1)
the_task.declare_interm_fluent(vy(v), 1)
the_task.declare_action_fluent(ux(v), 0.0)
the_task.declare_action_fluent(uy(v), 0.0)
the_task.declare_non_fluent(dt(), 0.0)
the_task.declare_non_fluent(mu_w(), 0.0)
the_task.declare_non_fluent(sigma_w(), 0.0)
the_task.declare_non_fluent(wx(wpt), 0.0)
the_task.declare_non_fluent(wy(wpt), 0.0)
the_task.declare_non_fluent(wr(), 0.0)
the_writer = rddl.Writer(the_task)
rddl_filename = os.path.join(tempfile.gettempdir(),
'lqg_nav_2d_multi_unit_bool_waypoints.rddl')
the_writer.write_model(rddl_filename)
mr_reader = rddl.Reader(rddl_filename)
assert mr_reader.rddl_model is not None
assert mr_reader.rddl_model.domain.name == 'lqg_nav_2d_multi_unit_bool_waypoints'
mr_reader.translate_rddl_model()
assert mr_reader.language is not None
def test_parametrized_model_with_random_vars():
lang = tarski.language(
'lqg_nav_2d_multi_unit',
[Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM])
the_task = Task(lang, 'lqg_nav_2d_multi_unit', 'instance_001')
the_task.requirements = [
rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET
]
the_task.parameters.discount = 1.0
the_task.parameters.horizon = 10
the_task.parameters.max_nondef_actions = 1
vehicle = lang.sort('vehicle', lang.Object)
# variables
x = lang.function('x', vehicle, lang.Real)
y = lang.function('y', vehicle, lang.Real)
vx = lang.function('vx', vehicle, lang.Real)
vy = lang.function('vy', vehicle, lang.Real)
ux = lang.function('ux', vehicle, lang.Real)
uy = lang.function('uy', vehicle, lang.Real)
t = lang.function('t', lang.Real)
# objects
v001 = lang.constant('v001', vehicle)
# non fluents
dt = lang.function('dt', lang.Real)
gx = lang.function('gx', lang.Real)
gy = lang.function('gy', lang.Real)
# Perturbation distribution parameters
mu_w = lang.function('mu_w', lang.Real)
sigma_w = lang.function('sigma_w', lang.Real)
# logical variable
v = lang.variable('v', vehicle)
# cpfs
the_task.add_cpfs(t(), t() + dt())
the_task.add_cpfs(vx(v), vx(v) + dt() * ux(v) + normal(mu_w(), sigma_w()))
the_task.add_cpfs(vy(v), vy(v) + dt() * uy(v) + normal(mu_w(), sigma_w()))
the_task.add_cpfs(x(v), x(v) + dt() * vx(v))
the_task.add_cpfs(y(v), y(v) + dt() * vy(v))
# constraints
the_task.add_constraint(
forall(v, (ux(v) >= -1.0) & (ux(v) <= 1.0) & (uy(v) >= -1.0) &
(uy(v) <= 1.0)), rddl.ConstraintType.ACTION)
the_task.add_constraint(
forall(v, (sqrt(vx(v) * vx(v) + vy(v) * vy(v)) <= 5.0)),
rddl.ConstraintType.STATE)
the_task.add_constraint(forall(v, (x(v) >= -100.0) & (x(v) <= 100.0)),
rddl.ConstraintType.STATE)
the_task.add_constraint(forall(v, (y(v) >= -100.0) & (y(v) <= 100.0)),
rddl.ConstraintType.STATE)
# cost function
Q = sumterm(v, ((x(v) - gx()) * (x(v) - gx())) + ((y(v) - gy()) *
(y(v) * gy())))
# MRJ: RDDL does not support the abs() algebraic construct
R = sumterm(
v,
ite(
sqrt(vx(v) * vx(v) + vy(v) * vy(v)) > 0.0,
(ux(v) * ux(v) * 0.01) + (uy(v) * uy(v) * 0.01),
lang.constant(0.0, lang.Real)))
# R = u() * u() * 0.01
the_task.reward = Q + R
# definitions
the_task.x0.set(x(v001), 0.0)
the_task.x0.set(y(v001), 0.0)
the_task.x0.set(vx(v001), 0.0)
the_task.x0.set(vy(v001), 0.0)
the_task.x0.set(ux(v001), 0.0)
the_task.x0.set(uy(v001), 0.0)
the_task.x0.set(t(), 0.0)
the_task.x0.set(dt(), 0.5)
the_task.x0.set(gx(), 20.0)
the_task.x0.set(gy(), 20.0)
the_task.x0.set(mu_w(), 0.0)
the_task.x0.set(sigma_w(), 0.05)
# fluent metadata
the_task.declare_state_fluent(x(v), 0.0)
the_task.declare_state_fluent(y(v), 0.0)
the_task.declare_state_fluent(t(), 0.0)
the_task.declare_interm_fluent(vx(v), 1)
the_task.declare_interm_fluent(vy(v), 1)
the_task.declare_action_fluent(ux(v), 0.0)
the_task.declare_action_fluent(uy(v), 0.0)
the_task.declare_non_fluent(dt(), 0.0)
the_task.declare_non_fluent(gx(), 0.0)
the_task.declare_non_fluent(gy(), 0.0)
the_task.declare_non_fluent(mu_w(), 0.0)
the_task.declare_non_fluent(sigma_w(), 0.0)
the_writer = rddl.Writer(the_task)
rddl_filename = os.path.join(tempfile.gettempdir(),
'lqg_nav_2d_multi_unit_001.rddl')
the_writer.write_model(rddl_filename)
mr_reader = rddl.Reader(rddl_filename)
assert mr_reader.rddl_model is not None
assert mr_reader.rddl_model.domain.name == 'lqg_nav_2d_multi_unit'
mr_reader.translate_rddl_model()
assert mr_reader.language is not None
def test_instance_creation():
L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC])
int_t = L.Integer
obj_t = L.Object
platform_t = L.sort('platform')
rov1 = L.constant('rov1', platform_t)
direction = L.function('direction', platform_t, int_t)
sensor_sort = L.sort('sensor')
camera, range, bearing = [L.constant(name, sensor_sort) for name in ('camera', 'range', 'bearing')]
engaged = L.function('engaged', sensor_sort, int_t)
region_t = L.sort('region')
p0 = L.constant('p0', region_t)
p1 = L.constant('p1', region_t)
p2 = L.constant('p2', region_t)
t0 = L.constant('t0', obj_t)
t1 = L.constant('t1', obj_t)
t2 = L.constant('t2', obj_t)
#t0, t1, t2 = [L.constant('t{}'.format(i), obj_t)
# for i in range(3)]
position = L.predicate('position', obj_t, region_t)
observed = L.predicate('observed', obj_t)
estimated_range = L.predicate('estimated_range', obj_t)
estimated_bearing = L.predicate('estimated_bearing', obj_t)
req_1 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(camera)
})
req_2 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(range)
})
req_3 = temporal.ResourceLock(**{
"ts": 0.0, "td": 10.0, "r": engaged(bearing)
})
req_4 = temporal.ResourceLevel(**{
"ts": 0.0, "td": 20.0, "r": direction(rov1), "n": L.constant(0, int_t)
})
a1 = temporal.Action(
name='localize_t0',
parameters=[],
precondition=position(rov1, p0),
requirements=[
TimedEffect(0.0, req_2),
TimedEffect(0.0, req_3)],
timed_effects=[
TimedEffect(15.0, estimated_range(t0)),
TimedEffect(20.0, estimated_bearing(t0))],
untimed_effects=[]
)
a2 = temporal.Action(
name='observed_t0',
parameters=[],
precondition=land(position(rov1, p0), estimated_range(t0), estimated_bearing(t0)),
requirements=[
TimedEffect(0.0, req_1),
TimedEffect(0.0, req_2)],
timed_effects=[
TimedEffect(21.0, observed(t0))],
untimed_effects=[]
)
initial = Model(L)
initial.add(position, rov1, p0)
initial.evaluator = evaluate
inst = temporal.Instance(
L=L,
X=[position(rov1, p0),
estimated_range(t0), estimated_bearing(t0), observed(t0),
estimated_range(t1), estimated_bearing(t1), observed(t1),
estimated_range(t2), estimated_bearing(t2), observed(t2)],
I=initial,
A=[a1, a2],
G=observed(t0)
)
assert len(inst.R) == 3
