def set_unit_costs(domain, unit_costs):
if not unit_costs and has_costs(domain):
return False
# Set the cost scale to be one?
for action in domain.actions:
action.cost = make_cost(1)
return True
def get_stream_actions(results,
unique_binding=False,
unit_efforts=True,
effort_scale=1):
#from pddl_parser.parsing_functions import parse_action
import pddl
stream_result_from_name = {}
stream_actions = []
for i, result in enumerate(results):
#if not isinstance(stream_result, StreamResult):
if type(result) == FunctionResult:
continue
effort = get_instance_effort(result.instance, unit_efforts)
if effort == INF:
continue
# TODO: state constraints
# TODO: selectively negate axioms
result_name = '{}-{}'.format(result.external.name, i)
#result_name = '{}_{}_{}'.format(result.external.name, # No spaces & parens
# ','.join(map(pddl_from_object, result.instance.input_objects)),
# ','.join(map(pddl_from_object, result.output_objects)))
assert result_name not in stream_result_from_name
stream_result_from_name[result_name] = result
preconditions = list(result.instance.get_domain())
effects = list(result.get_certified())
#if ORDER_OUTPUT:
# enforce_output_order(result, preconditions, effects)
if unique_binding:
enforce_single_binding(result, preconditions, effects)
if is_optimizer_result(
result): # These effects don't seem to be pruned
effects.append(
substitute_expression(result.external.stream_fact,
result.get_mapping()))
parameters = [] # Usually all parameters are external
stream_actions.append(
pddl.Action(name=result_name,
parameters=parameters,
num_external_parameters=len(parameters),
precondition=make_preconditions(preconditions),
effects=make_effects(effects),
cost=make_cost(effort_scale *
effort))) # Can also be None
return stream_actions, stream_result_from_name
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)
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)
preconditions = [stream_atom] + list(stream.domain)
effort = 1 # TODO: use stream info
#effort = 1 if unit_cost else result.instance.get_effort()
#if effort == INF:
# continue
domain.actions.append(
pddl.Action(name='call-{}'.format(stream.name),
parameters=parameters,
num_external_parameters=len(parameters),
precondition=make_preconditions(preconditions),
effects=make_effects(stream.certified),
cost=make_cost(effort)))
stream.certified = tuple(
set(stream.certified) | set(map(rename_future, stream.certified)))
def set_unit_costs(domain):
# Cost of None becomes zero if metric = True
set_cost_scale(1)
for action in domain.actions:
action.cost = make_cost(1)