def allocate_register(self, register_slot):
if not self.is_slot_available(register_slot):
return False
prop = self.game.proponent
register_clean = str(prop.values[register_slot]) == 'I'
terms = [goal.term for goal in self.goals]
register_access = (cards.get, number_term(register_slot))
register_cost = sequential_cost(register_access)
sub_term, advantage = optimal_subterm(register_cost, *terms)
if not register_clean:
advantage -= 1
# because we have to clean it up
if advantage <= 0:
return False
sub_goal = Goal(sub_term, register_slot)
self.introduce_get(sub_term, register_access)
self.add_goal(sub_goal)
return True
def rec(cur, depth):
global cnt
scur = str(cur)
if scur.isdigit() and scur not in optimized_numbers:
t = terms.number_term(int(scur))
cost = terms.sequential_cost(t)
if cost > len(steps):
print len(steps), steps_to_str(steps), "->", scur
optimized_numbers.add(scur)
if scur in desired:
print len(steps), steps_to_str(steps), "->", scur
desired.remove(scur)
if len(desired) == 0:
print "Done. Press enter to exit"
raw_input()
exit()
if depth == 0:
return
cnt += 1
if cnt % 500000 == 0:
print cnt
for i, (f, side) in enumerate(possible_steps):
if len(steps) == 0 and i % num_parts != our_part:
continue
try:
context.app_limit = 30
if side == "r":
next = apply(cur, f, context)
else:
next = apply(f, cur, context)
except Error as e:
continue
# except Exception as e:
# print steps_to_str(steps+[(f, side)])
# print e
# raise e
# exit()
steps.append((f, side))
rec(next, depth - 1)
steps.pop()
def reuse_shit(self):
assert self.current_goal is None
prop = self.game.proponent
terms = [goal.term for goal in self.goals]
costs, _ = calc_costs_and_weights(*terms)
for slot in slot_numbers_by_reachability:
if prop.vitalities[slot] <= 0:
continue
value = prop.values[slot]
if value == cards.I:
continue # for speed
shit = value_to_term(value)
shit = unfold_numbers(shit)
if shit in costs:
access = (cards.get, number_term(slot))
if sequential_cost(access) < costs[shit]:
if self.is_slot_available(slot):
self.introduce_get(shit, access)
del costs[shit]
def cost(self):
return sequential_cost(self.term)
def introduce_get(self, sub_term, register_access):
g, register_slot = fold_numbers(register_access)
assert isinstance(register_slot, int)
assert g == cards.get
self.gets.add(register_slot)
if not is_subterm_eager(sub_term, self.term):
self.lazy_gets.add(register_slot)
self.term = replace_leaf_subterm(sub_term, register_access, self.term)
slot_numbers_by_reachability = sorted(
range(rules.SLOTS),
key=lambda n: sequential_cost(number_term(n)))
class NetworkFail(Exception):
pass
def global_optimize_network(network):
best = None
best_cost = 1e100
orig = str(network)
for reg_count in [1]+[3]*5:
assert str(network) == orig
t = network.clone()
t.reg_count = reg_count
t.refine()
