def __init__(self, optimizer, constraint, domain, fluents):
self.optimizer = optimizer
self.constraint = constraint
inputs = get_args(constraint)
outputs = []
certified = [constraint]
name = '{}-{}'.format(optimizer.name, get_prefix(constraint))
gen_fn = get_gen_fn(optimizer.procedure, inputs, outputs, certified)
#gen_fn = empty_gen()
info = StreamInfo(effort_fn=get_effort_fn(optimizer.name), simultaneous=DEFAULT_SIMULTANEOUS)
self.stream_fact = Fact('_{}'.format(name), concatenate(inputs, outputs))
super(ConstraintStream, self).__init__(name, gen_fn, inputs, domain,
outputs, certified, info, fluents=fluents)
def __init__(self, optimizer, variable, inputs, domain, certified, info):
self.optimizer = optimizer
self.variable = variable
outputs = [variable]
name = '{}-{}'.format(optimizer.name, get_parameter_name(variable))
gen_fn = get_gen_fn(optimizer.procedure, inputs, outputs, certified)
#gen_fn = empty_gen()
#info = StreamInfo(effort_fn=get_effort_fn(optimizer_name, inputs, outputs))
#info = StreamInfo(opt_gen_fn=PartialInputs(unique=DEFAULT_UNIQUE, num=DEFAULT_NUM))
# Each stream could certify a stream-specific fact as well
# TODO: will I need to adjust simultaneous here as well?
info = StreamInfo(opt_gen_fn=PartialInputs(unique=DEFAULT_UNIQUE), simultaneous=DEFAULT_SIMULTANEOUS)
self.stream_fact = Fact('_{}'.format(name), concatenate(inputs, outputs)) # TODO: just add to certified?
super(VariableStream, self).__init__(name, gen_fn, inputs, domain,
outputs, certified, info)
def __init__(self, name, gen_fn, inputs, domain, outputs, certified, info, fluents=[]):
super(Stream, self).__init__(name, info, inputs, domain)
self.outputs = tuple(outputs)
self.certified = tuple(map(convert_constants, certified))
self.constants.update(a for i in certified for a in get_args(i) if not is_parameter(a))
for p, c in Counter(self.outputs).items():
if not is_parameter(p):
raise ValueError('Output [{}] for stream [{}] is not a parameter'.format(p, name))
if c != 1:
raise ValueError('Output [{}] for stream [{}] is not unique'.format(p, name))
for p in set(self.inputs) & set(self.outputs):
raise ValueError('Parameter [{}] for stream [{}] is both an input and output'.format(p, name))
certified_parameters = {a for i in certified for a in get_args(i) if is_parameter(a)}
for p in (certified_parameters - set(self.inputs + self.outputs)):
raise ValueError('Parameter [{}] for stream [{}] is not included within outputs'.format(p, name))
for p in (set(self.outputs) - certified_parameters):
print('Warning! Output [{}] for stream [{}] is not covered by a certified condition'.format(p, name))
# TODO: automatically switch to unique if only used once
self.gen_fn = get_debug_gen_fn(self, shared=True) if gen_fn == DEBUG else gen_fn
assert callable(self.gen_fn)
self.num_opt_fns = 0 if self.is_test() else 1 # Always unique if no outputs
if isinstance(self.info.opt_gen_fn, PartialInputs):
#self.info.opt_gen_fn.register(self)
if self.info.opt_gen_fn.unique:
self.num_opt_fns = 0
#self.bound_list_fn = None # TODO: generalize to a hierarchical sequence
#self.opt_fns = [get_unique_fn(self), get_shared_fn(self)] # get_unique_fn | get_shared_fn
self.fluents = fluents
#self.fluents = [] if gen_fn == DEBUG else fluents
if NEGATIVE_BLOCKED:
self.blocked_predicate = '~{}{}'.format(self.name, NEGATIVE_SUFFIX) # Args are self.inputs
else:
self.blocked_predicate = '~{}'.format(self.name)
self.disabled_instances = [] # For tracking disabled axioms
self.stream_fact = Fact('_{}'.format(name), concatenate(inputs, outputs)) # TODO: just add to certified?
if self.is_negated():
if self.outputs:
raise ValueError('Negated streams cannot have outputs: {}'.format(self.outputs))
#assert len(self.certified) == 1 # TODO: is it okay to have more than one fact?
for certified in self.certified:
if not (set(self.inputs) <= set(get_args(certified))):
raise ValueError('Negated streams must have certified facts including all input parameters')