def create_complex_symbol(a,b):
return Function("p",[
Function("",[
Number(1), Function("",[
Number(1), Function("",[
Number(1), Function("pt",[
Number(a),Number(b)])])])])])
def search_optimal(prg, utility_message, variables):
# only want one optimal variable assignment for each combination.
prg.configuration.solve.models = 0
# ground variables first.
for variable in variables:
prg.ground([("utility_optimization_variables", [variable])])
# for each combination, find the optimal variable assignment.
for query_assignment in utility_message:
# store assignments
assignments = []
# simple print like clingo
print("Utility Dimension")
print(query_assignment)
# combination is a symbol class.
for symbol in query_assignment:
# a string of the function
name = symbol.name
# a list of symbols, use .name
arguments = symbol.arguments
if name == "assignment":
assignments.append(arguments)
# assign_external the assignments to
for assignment in assignments:
prg.assign_external(Function("query_assignment", assignment), True)
optimal_symbols = []
with prg.solve(yield_=True) as handle:
for model in handle:
optimal_symbols.append(model.symbols(shown=True))
for assignment in assignments:
prg.release_external(Function("query_assignment", assignment))
print("Utility Optimization")
print(optimal_symbols)
print("")
def start(self, on_finish):
if self.ret is not None and not self.ret.unknown():
self.k = self.k + 1
self.prg.ground([("sleep", [self.k])])
self.prg.release_external(Function("sleep", [Number(self.k - 1)]))
self.prg.assign_external(Function("sleep", [Number(self.k)]), True)
self.future = self.prg.solve(on_model=self.on_model,
on_finish=on_finish,
async_=True)
def _map(self, lit):
sign = False
if lit < 0:
sign = True
lit = -lit
ret = self._symbols.get(lit, Function("__aux"))
if sign:
ret = Function("neg", [ret])
return ret
def test_register_name(self):
SF = StringField
IF = IntegerField
CF = ConstantField
n1 = Number(1)
n2 = Number(2)
n3 = Number(3)
n4 = Number(4)
s1 = String("ab")
s2 = String("cd")
s3 = String("abcd")
c1 = Function("ab", [])
c2 = Function("cd", [])
c3 = Function("abcd", [])
# Test the register_name as a decorator
cb1 = ContextBuilder()
@cb1.register_name("addi") # use function annotations
def add1(a: IF, b: IF) -> IF:
return a + b # external signature
self.assertEqual(add1(1, 2), 3)
@cb1.register_name("adds", SF, SF, SF)
def add2(a, b):
return a + b
self.assertEqual(add2("ab", "cd"), "abcd")
# Non-decorator call - re-using a function but with a different signature
cb1.register_name("addc", CF, CF, CF, add1)
# Non-decorator call - setting a function with the function annotation
cb1.register_name("addi_alt", add1)
ctx1 = cb1.make_context()
self.assertEqual(ctx1.addi(n1, n2), n3)
self.assertEqual(ctx1.addi_alt(n1, n2), n3)
self.assertEqual(ctx1.adds(s1, s2), s3)
self.assertEqual(ctx1.addc(c1, c2), c3)
# Things that should fail
with self.assertRaises(TypeError) as ctx:
self.assertEqual(ctx1.addc(s1, s2), s3)
with self.assertRaises(TypeError) as ctx:
self.assertEqual(ctx1.addc(s1, s2), c3)
# Fails since add2 has no function annotations
with self.assertRaises(TypeError) as ctx:
cb1.register_name("addo", add2)
# Function name already assigned
with self.assertRaises(ValueError) as ctx:
cb1.register_name("addi", add1)
def test_ground(self):
'''
Test grounding with context and parameters.
'''
ctx = Context()
ctl = Control()
ctl.add('part', ['c'], 'p(@cb_num(c)).')
ctl.ground([('part', [Number(1)])], ctx)
symbols = [atom.symbol for atom in ctl.symbolic_atoms]
self.assertEqual(sorted(symbols), [Function('p', [Number(0)]), Function('p', [Number(2)])])
def handle_message(self, msg):
if msg == "interrupt":
self.state = SolveThread.STATE_IDLE
elif msg == "exit":
self.state = SolveThread.STATE_EXIT
elif msg == "less_pigeon_please":
self.prg.assign_external(Function("p"), False)
self.state = SolveThread.STATE_IDLE
elif msg == "more_pigeon_please":
self.prg.assign_external(Function("p"), True)
self.state = SolveThread.STATE_IDLE
elif msg == "solve":
self.state = SolveThread.STATE_SOLVE
else:
raise (RuntimeError("unexpected message: " + msg))
def main(self, prg, files):
for f in files:
prg.load(f)
prg.add("check", ["k"], "#external query(k).")
t = 0
sat = False
prg.ground([("base", [])])
while not sat:
t += 1
prg.ground([("step", [Number(t)])])
prg.ground([("check", [Number(t)])])
prg.release_external(Function("query", [Number(t - 1)]))
prg.assign_external(Function("query", [Number(t)]), True)
sat = prg.solve(on_model=self.__on_model).satisfiable
def _theory_atom_with_guard(self, atom_id_or_zero, term_id, elements,
operator_id, right_hand_side_id):
self._symbols[atom_id_or_zero] = Function("theory", [
self._terms[term_id](),
Tuple(sorted(set([self._elems[e]() for e in elements]))),
self._terms[operator_id](), self._terms[right_hand_side_id]()
])
def test_repr(self):
'''
Test representation of symbols.
'''
self.assertEqual(
repr(Function('test', [Number(10), Infimum, Supremum, String("test")], False)),
"Function('test', [Number(10), Infimum, Supremum, String('test')], False)")