def get_stream_action(result, name, unit_cost, effect_scale=1):
#from pddl_parser.parsing_functions import parse_action
import pddl
parameters = []
preconditions = [
fd_from_fact(fact) for fact in result.instance.get_domain()
]
precondition = pddl.Conjunction(preconditions)
effects = [
pddl.Effect(parameters=[],
condition=pddl.Truth(),
literal=fd_from_fact(fact))
for fact in result.get_certified()
]
effort = 1 if unit_cost else result.instance.get_effort()
if effort == INF:
return None
fluent = pddl.PrimitiveNumericExpression(symbol=TOTAL_COST, args=[])
expression = pddl.NumericConstant(int_ceil(effect_scale *
effort)) # Integer
cost = pddl.Increase(fluent=fluent,
expression=expression) # Can also be None
return pddl.Action(name=name,
parameters=parameters,
num_external_parameters=len(parameters),
precondition=precondition,
effects=effects,
cost=cost)
def compile_to_exogenous_actions(evaluations, domain, streams):
import pddl
# TODO: automatically derive fluents
# TODO: version of this that operates on fluents of length one?
# TODO: better instantiation when have full parameters
# TODO: conversion from stream cost to real cost units?
# TODO: any predicates derived would need to be replaced as well
fluent_predicates = get_fluents(domain)
domain_predicates = {get_prefix(a) for s in streams for a in s.domain}
if not (domain_predicates & fluent_predicates):
return
certified_predicates = {get_prefix(a) for s in streams for a in s.certified}
future_map = {p: 'f-{}'.format(p) for p in certified_predicates}
augment_evaluations(evaluations, future_map)
rename_future = lambda a: rename_atom(a, future_map)
for stream in list(streams):
if not isinstance(stream, Stream):
raise NotImplementedError(stream)
# TODO: could also just have conditions asserting that one of the fluent conditions fails
streams.append(create_static_stream(stream, evaluations, fluent_predicates, rename_future))
stream_atom = streams[-1].certified[0]
parameters = [pddl.TypedObject(p, 'object') for p in get_args(stream_atom)]
# TODO: add to predicates as well?
domain.predicate_dict[get_prefix(stream_atom)] = pddl.Predicate(get_prefix(stream_atom), parameters)
precondition = pddl.Conjunction(tuple(map(fd_from_fact, (stream_atom,) + tuple(stream.domain))))
effects = [pddl.Effect(parameters=[], condition=pddl.Truth(),
literal=fd_from_fact(fact)) for fact in stream.certified]
effort = 1 # TODO: use stream info
#effort = 1 if unit_cost else result.instance.get_effort()
#if effort == INF:
# continue
fluent = pddl.PrimitiveNumericExpression(symbol=TOTAL_COST, args=[])
expression = pddl.NumericConstant(int_ceil(effort)) # Integer
cost = pddl.Increase(fluent=fluent, expression=expression) # Can also be None
domain.actions.append(pddl.Action(name='call-{}'.format(stream.name),
parameters=parameters,
num_external_parameters=len(parameters),
precondition=precondition, effects=effects, cost=cost))
stream.certified = tuple(set(stream.certified) |
set(map(rename_future, stream.certified)))
def convert_cost(cost):
if cost == INF:
return INFINITY
return int_ceil(cost)
def scale_cost(cost):
if cost == INF:
return INF
return int_ceil(get_cost_scale() * float(cost))
def convert_value(value):
if value == INF:
return INFINITY
return int_ceil(value)
def scale_cost(cost):
return int_ceil(get_cost_scale() * float(cost))
