def clingo_solve(self, inp):
print('solving with clingo...')
num = self.max_time
ms0 = num
while True:
solv = asp_solver.IncrementalSolver(num, self.num_agents,
self.min_sum, self.total_cost,
ms0, True, True)
clingo.clingo_main(solv, [
inp, 'bases/baseE.lp', '--opt-strat=usc,disjoint', '--outf=3',
'--time-limit=300', '-c', 'bound={0}'.format(num)
])
if solv.sol_cost > 0:
self.sol = solv.resp
self.check_makespan()
print('Encontrada Primera Solucion')
print('\tCosto total: {0}'.format(solv.sol_cost))
print('\tMakespan: {0}'.format(self.sol_time))
ms = int(solv.theoric_makespan)
if ms > num:
num = ms
solv = asp_solver.IncrementalSolver(
num, self.num_agents, self.min_sum, self.total_cost,
ms0, True, True)
clingo.clingo_main(solv, [
inp, 'bases/baseE.lp', '--opt-strat=usc,disjoint',
'--outf=3', '--time-limit=300', '-c',
'bound={0}'.format(ms)
])
break
num += 1
self.sol = solv.resp
self.check_makespan()
print('-----------------')
print('Encontrada Solucion Optima, Estadisticas Clingo:')
#print(json.dumps(solv.stats, sort_keys=True, indent=4, separators=(',', ': ')))
print('Encontrada Solucion')
print('\tCosto total: {0}'.format(solv.sol_cost))
print('\tMakespan: {0}'.format(self.sol_time))
print('-----------------')
elif atom.name == "jump" and len(atom.arguments) == 4:
ox, oy, d, t = ((n.number if n.type == clingo.SymbolType.Number
else str(n)) for n in atom.arguments)
jumps.setdefault(t, []).append(
(ox, oy, ox + sx[d], oy + sy[d]))
try:
MainWindow().run(Plan(field, init, jumps))
return True
except KeyboardInterrupt:
return False
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", [t])])
prg.ground([("check", [t])])
prg.release_external(clingo.Function("query", [t - 1]))
prg.assign_external(clingo.Function("query", [t]), True)
sat = prg.solve(on_model=self.__on_model).satisfiable
sys.exit(int(clingo.clingo_main(Application("visualize"), sys.argv[1:])))
def run_problem(instance_path, base_path, results_path, penalty_type,
results_mode):
write_type = 'a'
if results_mode:
write_type = 'w'
with open(results_path, write_type) as results:
if results_mode:
results.write('sep=;\n')
results.write(
'Instance;cost_relax;makespan_relax;First_solved;solved;;'
'1stOPT;1stSOL-COST;1stMakespan;1stTheoricMakespan;1stRunTime;1stGroundTime;1stGroundPerc;1stAtoms;1stBodies;1stRules;1stTotal;;'
'OPT;SOL-COST;Makespan;TheoricMakespan;RunTime;GroundTime;GroundPerc;Atoms;Bodies;Rules;Total\n'
)
results.flush()
problem = lp_generator.Problem(50)
print('reading instance')
problem.read_instance(instance_path)
print('generating solution')
problem.gen_solution()
buffer_path = 'buffer'
problem.write_to_lp(buffer_path)
print('Solving with clingo...')
start_time = time.time()
ms_max = problem.max_time
ground_time = 0
ground_time0 = 0
runtime = 0
runtime0 = 0
makespan_relax = ms_max + 1
ms0 = ms_max
cost_relax = problem.total_cost
first_solved = False
solved = False
solv0 = None
solv = None
curr = 300
elapsed_real = 0
try:
while True:
solv0 = asp_solver.IncrementalSolver(ms_max,
problem.num_agents,
problem.min_sum,
problem.total_cost, ms0,
penalty_type, False)
clingo.clingo_main(solv0, [
buffer_path, base_path, '--outf=3',
'--opt-strat=usc,disjoint',
'--time-limit={0}'.format(curr), '-t', '4', '-c',
'bound={0}'.format(ms_max)
])
ground_time += solv0.ground_time
elapsed_real += (solv0.solve_time + solv0.ground_time)
if solv0.error:
break
curr = int(300 - elapsed_real)
if curr < 0:
break
if solv0.sol_cost > 0:
runtime0 = elapsed_real
first_ms = ms_max + 1
ms_opt = int(solv0.theoric_makespan)
first_solved = True
ground_time0 = ground_time
if ms_opt == ms_max:
solv = solv0
solved = True
runtime = runtime0
final_ms = first_ms
break
solv = asp_solver.IncrementalSolver(
ms_opt, problem.num_agents, problem.min_sum,
problem.total_cost, ms0, penalty_type, True)
clingo.clingo_main(solv, [
buffer_path, base_path, '--outf=3',
'--opt-strat=usc,disjoint',
'--time-limit={0}'.format(curr), '-t', '4', '-c',
'bound={0}'.format(ms_opt)
])
ground_time += solv.ground_time
if solv.stats is not None:
runtime = elapsed_real + (solv.solve_time +
solv.ground_time)
final_ms = check_makespan(solv.resp)
summary = solv.stats['summary']
solved = True
break
ms_max += 1
except:
print(traceback.format_exc())
row = [instance_path]
row.append(cost_relax)
row.append(makespan_relax)
if first_solved:
row.append(1)
row.append(0)
row.append('\t')
row.append(format_float(solv0.stats['summary']['costs'][0]))
row.append(format_float(solv0.sol_cost))
row.append(first_ms)
row.append(int(solv0.theoric_makespan) + 1)
row.append(format_float(runtime0))
row.append(format_float(ground_time0))
row.append(format_float(ground_time0 / runtime0 * 100))
row.append(format_float(solv0.stats['problem']['lp']['atoms']))
row.append(format_float(solv0.stats['problem']['lp']['bodies']))
row.append(format_float(solv0.stats['problem']['lp']['rules']))
row.append(
format_float(solv0.stats['problem']['lp']['atoms'] +
solv0.stats['problem']['lp']['bodies'] +
solv0.stats['problem']['lp']['rules']))
row.append('\t')
if solved:
row[4] = 1
row.append(format_float(solv.stats['summary']['costs'][0]))
row.append(format_float(solv.sol_cost))
row.append(final_ms)
row.append(int(solv.theoric_makespan) + 1)
row.append(format_float(runtime))
row.append(format_float(ground_time))
row.append(format_float(ground_time / runtime * 100))
row.append(format_float(solv.stats['problem']['lp']['atoms']))
row.append(format_float(solv.stats['problem']['lp']['bodies']))
row.append(format_float(solv.stats['problem']['lp']['rules']))
row.append(
format_float(solv.stats['problem']['lp']['atoms'] +
solv.stats['problem']['lp']['bodies'] +
solv.stats['problem']['lp']['rules']))
else:
row.append(0)
row.append(0)
results.write(';'.join(map(str, row)) + '\n')
results.flush()
def _main(self, ctl):
step, ret = 0, None
while ((self._imax is None or step < self._imax)
and (step == 0 or step < self._imin or
((self._istop == "SAT" and not ret.satisfiable) or
(self._istop == "UNSAT" and not ret.unsatisfiable) or
(self._istop == "UNKNOWN" and not ret.unknown)))):
parts = []
parts.append(("base", [Number(step)]))
parts.append(("static", [Number(step)]))
if step > 0:
ctl.release_external(Function("finally", [Number(step - 1)]))
parts.append(("dynamic", [Number(step)]))
else:
parts.append(("initial", [Number(0)]))
ctl.ground(parts)
ctl.assign_external(Function("finally", [Number(step)]), True)
ret, step = ctl.solve(), step + 1
def main(self, ctl, files):
with ast.ProgramBuilder(ctl) as bld:
ptf = ProgramTransformer(Function("__t"))
ast.parse_files(files, lambda stm: bld.add(ptf(stm)))
ctl.add("initial", ["t"], "initially(t).")
ctl.add("static", ["t"], "#external finally(t).")
self._main(ctl)
exit(clingo_main(TModeApp()))
if __name__ == '__main__':
instance_dir = 'benchmarks/random_graphs/'
graph_instances = os.listdir(instance_dir)
graph_instances.sort(
key=lambda x: (get_parameters(x)[0], get_parameters(x)[1]))
running_times = {}
for idx, g in enumerate(graph_instances):
num_nodes, p = get_parameters(g)
graph_path = os.path.join(instance_dir, g)
current_files = [
'benchmarks/relaxed_clique.lpmln', graph_path, '--outf=3'
]
start = time.time()
exit_code = clingo_main(LPMLNApp(), current_files)
end = time.time()
running_times[str(idx)] = {
'N': num_nodes,
'p': p,
'time': end - start,
'file': g
}
with open('running_times.json', 'w') as fp:
json.dump(running_times, fp)
print(f'\n Num. nodes: {num_nodes}, probability: {p}')
print(end - start)
def main():
"""
Run the xorro application.
"""
_sys.exit(int(_clingo.clingo_main(Application("xorro"), _sys.argv[1:])))
def main_clingo(args=None):
sys.exit(int(clingo.clingo_main(Application(), sys.argv[1:])))
'''
Module providing the clingo-like pyclingo application.
'''
from clingo import Application, clingo_main
class PyClingoApplication(Application):
'''
This is an example app mimimicking clingo.
'''
program_name = "pyclingo"
def main(self, control, files):
for file_ in files:
control.load(file_)
if not files:
control.load('-')
control.ground([('base', [])])
control.solve()
if __name__ == '__main__':
clingo_main(PyClingoApplication())
class MultiJobShopApp(clingo.Application):
program_name = "multi-jobshop"
version = "1.0"
def __init__(self):
self._model = None
def _on_model(self, model):
if model.optimality_proven:
self._model = model.symbols(shown=True)
def main(self, ctl, files):
for path in files:
ctl.load(path)
if not files:
ctl.load("-")
ctl.ground([("base", [])], context=self)
# for every time window
for window in range(1, ctl.get_const("w").number + 1):
# do something else...
ctl.solve(on_model=self._on_model)
if self._model:
print("Answer:\n{}".format(" ".join(
[str(atom) for atom in self._model])))
if __name__ == "__main__":
clingo.clingo_main(MultiJobShopApp(), sys.argv[1:])
symbols = model.symbols(theory=True)
assignment = []
for symbol in sorted(symbols):
if symbol.match("__lpx", 2):
args = symbol.arguments
assignment.append(f"{args[0]}={args[1].string}")
sys.stdout.write(" ".join(assignment))
sys.stdout.write('\n')
sys.stdout.flush()
def main(self, control, files):
self.__theory.register(control)
with ast.ProgramBuilder(control) as bld:
ast.parse_files(files, lambda stm: self.__theory.rewrite_ast(stm, bld.add))
control.ground([("base", [])])
self.__theory.prepare(control)
control.solve(on_model=self.__on_model, on_statistics=self.__on_statistics)
def __on_model(self, model):
self.__theory.on_model(model)
def __on_statistics(self, step, accu):
self.__theory.on_statistics(step, accu)
if __name__ == "__main__":
sys.exit(int(clingo.clingo_main(Application("clingo-lpx"), sys.argv[1:])))
import sys
import clingo
import json
class Application:
def __init__(self, name, minimum_time):
self.program_name = name
self.minimum_time = minimum_time
def main(self, ctl, files):
if len(files) > 0:
for f in files:
ctl.load(f)
else:
ctl.load("-")
ctl.ground([("base", [])])
ret = ctl.solve()
print(
json.dumps(ctl.statistics,
sort_keys=True,
indent=4,
separators=(',', ': ')))
if __name__ == '__main__':
print(sys.argv)
app = Application(sys.argv[0], 20)
ret = clingo.clingo_main(app, sys.argv[1:])
self.theory = thy
thy.register(ctl)
with ProgramBuilder(ctl) as bld:
parse_files(files, lambda ast: thy.rewrite_ast(ast, bld.add))
pareto_propagator = ParetoPropagator(thy, self.mode)
self.propagator = pareto_propagator
ctl.register_propagator(pareto_propagator)
ctl.ground([('base', [])])
thy.prepare(ctl)
thy.configure("propagate", self.dl_propagation_mode)
if self.mode == "breadth":
ctl.solve(on_model=self.on_model,
on_finish=self.print_front,
on_statistics=self._on_statistics)
elif self.mode == "depth":
models = 0
while models < self.nr_models or self.nr_models == 0:
r = ctl.solve(
on_model=self.on_model,
on_finish=lambda m: self.print_single(models + 1, m),
on_statistics=self._on_statistics)
if r.unsatisfiable: return
models += 1
self.propagator.save_best()
sys.exit(clingo_main(DSEApp(), sys.argv[1:]))
def run_problem(problem_folder, base_path, results_path, instance_name, window_size):
with open(results_path, 'a') as results:
path = '../problems/original/{0}/Instances/{1}'.format(problem_folder, instance_name)
#path = 'Instance-8-10-4-0'
#path = 'brc202d-70-0'
#path = 'ost003d-70-0'
problem = lp_generator.Problem(window_size)
print('reading instance')
problem.read_instance(path)
print('generating solution')
problem.gen_solution()
window_id = 0
#path = 'problems/asp/{0}/{1}-{2}'.format(problem_folder,instance_name, window_id)
path = 'buffer'
print('Solving with clingo...')
start_time = time.time()
max_bound = problem.max_time
print(max_bound)
ground_time = 0
curr_time = 600
solved = False
current_makespan = 0
current_costs = []
current_penalty = []
total_cost = 0
for ag in range(problem.num_agents):
current_costs.append(0)
current_penalty.append(0)
problem.write_to_lp_window(path, problem.agents_pos, current_penalty)
while True:
current_makespan += window_size
solv = asp_solver.IncrementalSolver('{0}.lp'.format(path), problem.num_agents, window_size)
clingo.clingo_main(solv, ['{0}.lp'.format(path), '{0}.lp'.format(base_path), '--opt-strat=usc,disjoint','--outf=3','--time-limit={0}'.format(curr_time), '-t', '4', '-c', 'window_bound={0}'.format(window_size)])
window_id+=1
ground_time += solv.ground_time
elapsed = time.time() - start_time
curr_time = int(600.0 - elapsed)
print(elapsed)
if curr_time < 0:
break
if solv.sol_cost < 0:
break
solved_agents = problem.check_solved(solv.final_pos)
all_solved = True
total_cost = 0
for ag in range(problem.num_agents):
if solved_agents[ag]:
current_penalty[ag] += window_size - (solv.current_costs[ag] - solv.reset_penalty[ag])
else:
all_solved = False
current_costs[ag] += solv.current_costs[ag]
total_cost += current_costs[ag]
#print(current_costs)
if all_solved:
solved = True
break
#x = input()
#path = 'problems/asp/{0}/{1}-{2}'.format(problem_folder,instance_name, window_id)
path = 'buffer'
problem.write_to_lp_window(path, solv.final_pos, current_penalty)
row = [instance_name]
if solved:
row.append(1)
else:
row.append(0)
row.append(ground_time)
row.append(elapsed)
row.append(total_cost)
row.append(window_id)
row.append(window_size)
results.write(';'.join(map(str, row)) + '\n')
results.flush()
def run_problem(problem_folder, base_path, results_path, instance_name):
with open(results_path, 'a') as results:
path = 'problems/original/{0}/Instances/{1}'.format(
problem_folder, instance_name)
problem = lp_generator.Problem(50, 0, 0)
print('reading instance')
problem.read_instance(path)
print('generating solution')
problem.gen_solution()
path = 'problems/asp/{0}/{1}'.format(problem_folder, instance_name)
problem.write_to_lp(path)
print('Solving with clingo...')
start_time = time.time()
num = problem.max_time
ground_time = 0
ground_time0 = 0
runtime = 0
runtime0 = 0
print(num)
first_solved = False
solved = False
solv0 = None
solv = None
curr = 300
while True:
solv0 = asp_solver.IncrementalSolver('{0}.lp'.format(path), num,
problem.num_agents,
problem.min_sum,
problem.total_cost, 4, False)
clingo.clingo_main(solv0, [
'{0}.lp'.format(path), '{0}.lp'.format(base_path), '--outf=3',
'--opt-strat=usc,disjoint', '--time-limit={0}'.format(curr),
'-t', '4', '-c', 'bound={0}'.format(num)
])
#print(solv0.ground_time)
ground_time += solv0.ground_time
elapsed = time.time() - start_time
curr = int(300 - elapsed)
print(curr)
if curr < 0:
break
if solv0.sol_cost > 0:
runtime0 = time.time() - start_time
ms = int(solv0.theoric_makespan)
first_solved = True
ground_time0 = ground_time
print(ms)
if ms == num:
solv = solv0
solved = True
runtime = runtime0
break
solv = asp_solver.IncrementalSolver('{0}.lp'.format(path), ms,
problem.num_agents,
problem.min_sum,
problem.total_cost, 4,
False)
clingo.clingo_main(solv, [
'{0}.lp'.format(path), '{0}.lp'.format(base_path),
'--outf=3', '--opt-strat=usc,disjoint',
'--time-limit={0}'.format(curr), '-t', '4', '-c',
'bound={0}'.format(ms)
])
ground_time += solv.ground_time
if solv.stats is not None:
runtime = time.time() - start_time
summary = solv.stats['summary']
solved = True
break
num += 1
print(num)
#sol = solv.resp
row = [instance_name]
#print(solv.sol_cost)
if first_solved:
#print(json.dumps(solv.stats, sort_keys=True, indent=4, separators=(',', ': ')))
row.append(1)
row.append(0)
row.append('\t')
row.append(format_float(solv0.stats['summary']['costs'][0]))
row.append(format_float(solv0.sol_cost))
row.append('-1')
row.append(int(solv0.theoric_makespan))
row.append(format_float(runtime0))
row.append(format_float(ground_time0))
row.append(format_float(ground_time0 / runtime0 * 100))
row.append(format_float(solv0.stats['problem']['lp']['atoms']))
row.append(format_float(solv0.stats['problem']['lp']['bodies']))
row.append(format_float(solv0.stats['problem']['lp']['rules']))
row.append(
format_float(solv0.stats['problem']['lp']['atoms'] +
solv0.stats['problem']['lp']['bodies'] +
solv0.stats['problem']['lp']['rules']))
row.append('\t')
if solved:
row[2] = 1
row.append(format_float(solv.stats['summary']['costs'][0]))
row.append(format_float(solv.sol_cost))
row.append('-1')
row.append(int(solv.theoric_makespan))
row.append(format_float(runtime))
row.append(format_float(ground_time))
row.append(format_float(ground_time / runtime * 100))
row.append(format_float(solv.stats['problem']['lp']['atoms']))
row.append(format_float(solv.stats['problem']['lp']['bodies']))
row.append(format_float(solv.stats['problem']['lp']['rules']))
row.append(
format_float(solv.stats['problem']['lp']['atoms'] +
solv.stats['problem']['lp']['bodies'] +
solv.stats['problem']['lp']['rules']))
else:
row.append(0)
row.append(0)
#print(elapsed)
#print(solv.resp)
#print(check_makespan(solv.resp))
results.write(';'.join(map(str, row)) + '\n')
results.flush()
with ctl.solve(yield_=True) as handle:
for model in handle:
if self.display_all_probs or self.query != []:
model_costs.append(model.cost)
if self.query != []:
self._check_model_for_query(model)
if model_costs != [] and (self.display_all_probs or self.query != []):
if 0 not in observer.priorities:
# TODO: Should this be error or warning?
print(
'No soft weights in program. Cannot calculate probabilites'
)
# TODO: What about case where there are other priorities than 0/1?
# elif not self.two_solve_calls and any(
# x > 1 for x in observer.priorities):
# print(observer.priorities)
# print('testasd')
else:
probs = ProbabilityModule(
model_costs, observer.priorities,
[self.translate_hard_rules, self.two_solve_calls])
if self.display_all_probs:
probs.print_probs()
if self.query != []:
probs.get_query_probability(self.query)
if __name__ == '__main__':
sys.exit(int(clingo_main(LPMLNApp(), sys.argv[1:])))
def run(problem_path, lp_path, base_path, landmarks, overflow):
num_landmarks = int(landmarks)
num_overflow = int(overflow)
problem = lp_generator.Problem(50, num_landmarks, num_overflow)
print('reading instance')
problem.read_instance(problem_path)
print('generating solution')
problem.gen_solution()
problem.write_to_lp(lp_path)
print('Solving with clingo...')
return
start_time = time.time()
num_makespan = problem.max_time + num_overflow
ground_time = 0
runtime = 0
first_solved = False
solved = False
curr_time = 300
print(num_makespan)
solv0 = asp_solver.IncrementalSolver('{0}.lp'.format(lp_path),
num_makespan, problem.num_agents,
problem.min_sum, problem.total_cost,
4, True)
clingo.clingo_main(solv0, [
'{0}.lp'.format(lp_path), '{0}'.format(base_path),
'--time-limit={0}'.format(curr_time), '-t', '4', '-c',
'bound={0}'.format(num_makespan), '-c',
'lbound={0}'.format(num_landmarks), '--opt-strategy=usc,disjoint',
'--text'
])
print(solv0.resp)
print('found solution: ')
print('\t total_cost: {0}'.format(solv0.sol_cost))
#print('\t makespan: {0}'.format(check_makespan(solv.resp)))
return
while curr_time >= 0:
print('solving with makespan: {0}'.format(num_makespan + 1))
solv0 = asp_solver.IncrementalSolver('{0}.lp'.format(lp_path),
num_makespan, problem.num_agents,
problem.min_sum,
problem.total_cost, 4, True)
clingo.clingo_main(solv0, [
'{0}.lp'.format(lp_path), '{0}'.format(base_path), '--outf=3',
'--opt-strat=usc,disjoint', '--time-limit={0}'.format(curr_time),
'-t', '4', '-c', 'bound={0}'.format(num_makespan)
])
ground_time += solv0.ground_time
elapsed = time.time() - start_time
curr_time = int(300 - elapsed)
if curr_time < 0:
break
if solv0.sol_cost > 0:
runtime0 = time.time() - start_time
ms = int(solv0.theoric_makespan)
first_solved = True
ground_time0 = ground_time
if ms == num_makespan:
solv = solv0
solved = True
runtime = runtime0
break
print('solving with makespan: {0}'.format(ms + 1))
solv = asp_solver.IncrementalSolver('buffer.lp'.format(lp_path),
ms, problem.num_agents,
problem.min_sum,
problem.total_cost, 4, True)
clingo.clingo_main(solv, [
'{0}.lp'.format(lp_path), '{0}'.format(base_path), '--outf=3',
'--opt-strat=usc,disjoint',
'--time-limit={0}'.format(curr_time), '-t', '4', '-c',
'bound={0}'.format(ms)
])
ground_time += solv.ground_time
if solv.stats is not None:
runtime = time.time() - start_time
ground_time += solv.ground_time
solved = True
break
num_makespan += 1
print('----------')
if solved:
print('found solution: ')
print('\t total_cost: {0}'.format(solv.sol_cost))
#print('\t makespan: {0}'.format(check_makespan(solv.resp)))
print('\t runtime: {0} seconds'.format(runtime))
print('\t ground_time: {0} seconds'.format(ground_time))
else:
print('No solution found')
def run_test(solver_type, problem_folder, call_extra, only_first_sol, base_path):
opt_makespans = []
if solver_type == 2:
with open('problems/original/{0}/opt_makespan'.format(problem_folder), 'r') as in_file:
opt_makespans = [int(line.strip()) for line in in_file]
with open('results/results_{0}_{1}_last.csv'.format(problem_folder, base_path.split('/')[-1]), 'w') as results:
results.write('sep=;\n')
'''
results.write('Instance; First_solved;solved;Models; Optimum; Calls;Threads;MIN-Timestep;Min-SUMTIME; ;'
'1stTime(Total); 1stTime(Solving);1stTime(Unsat); 1stCPU Time;1stOptimization;1stSOL-COST; 1st Makespan; ;'
'OPT - Optimization; OPT- Time(Total); OPT-Time(Solving); OPT-Time(Unsat); OPT-CPU Time; OPT-SOL-COST; Last-Makespan ;OPT-Makespan; OPT-Solved;'
'Moved On Goal; Theoric Makespan; 1stRunTime ;Total RunTime; Ground Time; Percent Grounding; Called Extra; Atoms; Bodies; Rules; Total\n')
'''
results.write('Instance; First_solved;solved;;'
'1stOPT;1stSOL-COST;1stMakespan;1stTheoricMakespan;1stRunTime;1stGroundTime;1stGroundPerc;1stAtoms;1stBodies;1stRules;1stTotal;;'
'OPT;SOL-COST;Makespan;TheoricMakespan;RunTime;GroundTime;GroundPerc;Atoms;Bodies;Rules;Total\n')
print(base_path.split('/')[-1])
i = 1
#l1 = [4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
#l1 = [0,5,10,15,20,25,30]
#l1 = [12,18,24,30]
#l1 = [14,16,18,20,22,24,26,28,30]
#l1 = [40,45,50,55,60,65,70,75,80]
l1 = [20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50]
#l1 = [42,44,46,48,50]
#l1 = [1,60,65,70,75,80,85,90,95,100,100]
#l1 = [42,44,46,48,50]
l1 = [50]
for x in l1:
for y in range(10):
name = 'Instance-20-10-{0}-{1}'.format(x,y)
#name = 'brc202d-{0}-{1}'.format(x,y)
path = 'problems/original/{0}/Instances/{1}'.format(problem_folder, name)
i+=1
if y != 5:
continue
#print(name)
'''
if x < 38:
continue
if x == 38 and (y <= 6 or y == 8):
continue
if x == 40 and (y == 0 or y == 2 or y == 3 or y == 4 or y == 8):
continue
'''
problem = lp_generator.Problem(50)
print('reading instance')
problem.read_instance(path)
print('generating solution')
problem.gen_solution()
path = 'problems/asp/{0}/{1}'.format(problem_folder,name)
problem.write_to_lp(path)
print('Solving with clingo...')
start_time = time.time()
num = problem.max_time
ground_time = 0
ground_time0 = 0
runtime = 0
runtime0 = 0
print(num)
first_solved = False
solved = False
solv0 = None
solv = None
curr = 300
while True:
solv0 = asp_solver.IncrementalSolver('{0}.lp'.format(path), num, problem.num_agents, problem.min_sum, problem.total_cost, solver_type, only_first_sol)
clingo.clingo_main(solv0, ['{0}.lp'.format(path), '{0}.lp'.format(base_path) , '--outf=3', '--opt-strat=usc,disjoint', '--time-limit={0}'.format(curr), '-t', '4', '-c','bound={0}'.format(num)])
#print(solv0.ground_time)
ground_time += solv0.ground_time
elapsed = time.time() - start_time
curr = int(300 - elapsed)
print(curr)
if curr < 0:
break
if solv0.sol_cost > 0:
runtime0 = time.time() - start_time
ms = int(solv0.theoric_makespan)
first_solved = True
ground_time0 = ground_time
print(ms)
if ms == num:
solv = solv0
solved = True
runtime = runtime0
break
break
solv = asp_solver.IncrementalSolver('{0}.lp'.format(path), ms, problem.num_agents, problem.min_sum, problem.total_cost, solver_type, only_first_sol)
clingo.clingo_main(solv, ['{0}.lp'.format(path), '{0}.lp'.format(base_path) , '--outf=3', '--opt-strat=usc,disjoint', '--time-limit={0}'.format(curr), '-t', '4', '-c','bound={0}'.format(ms)])
ground_time += solv.ground_time
if solv.stats is not None:
runtime = time.time() - start_time
summary = solv.stats['summary']
solved = True
break
num += 1
print(num)
#sol = solv.resp
row = [name]
#print(solv.sol_cost)
if first_solved:
#print(json.dumps(solv.stats, sort_keys=True, indent=4, separators=(',', ': ')))
row.append(1)
row.append(0)
row.append('\t')
row.append(format_float(solv0.stats['summary']['costs'][0]))
row.append(format_float(solv0.sol_cost))
row.append('-1')
row.append(int(solv0.theoric_makespan))
row.append(format_float(runtime0))
row.append(format_float(ground_time0))
row.append(format_float(ground_time0/runtime0*100))
row.append(format_float(solv0.stats['problem']['lp']['atoms']))
row.append(format_float(solv0.stats['problem']['lp']['bodies']))
row.append(format_float(solv0.stats['problem']['lp']['rules']))
row.append(format_float(solv0.stats['problem']['lp']['atoms'] + solv0.stats['problem']['lp']['bodies'] + solv0.stats['problem']['lp']['rules']))
row.append('\t')
if solved:
row[2] = 1
row.append(format_float(solv.stats['summary']['costs'][0]))
row.append(format_float(solv.sol_cost))
row.append('-1')
row.append(int(solv.theoric_makespan))
row.append(format_float(runtime))
row.append(format_float(ground_time))
row.append(format_float(ground_time/runtime*100))
row.append(format_float(solv.stats['problem']['lp']['atoms']))
row.append(format_float(solv.stats['problem']['lp']['bodies']))
row.append(format_float(solv.stats['problem']['lp']['rules']))
row.append(format_float(solv.stats['problem']['lp']['atoms'] + solv.stats['problem']['lp']['bodies'] + solv.stats['problem']['lp']['rules']))
else:
row.append(0)
row.append(0)
#print(elapsed_time)
#print(solv.resp)
#print(check_makespan(solv.resp))
results.write(';'.join(map(str, row)) + '\n')
results.flush()
if sym.name == "on":
args = sym.arguments
robot = int(args[0].name[-1:]) - 1
if sym.name == "exec":
args = sym.arguments
robot = int(args[0].name[-1:]) - 1
if robot == 2:
print(sym)
if sym.name == "penalty":
args = sym.arguments
robot = int(args[0].name[-1:]) - 1
if robot == 2:
print(sym)
print(m.optimality_proven, "????")
if __name__ == '__main__':
min_bound = 10
while True:
app = Application(sys.argv[0], min_bound)
args = sys.argv[1:]
args.append("-c")
args.append("bound={0}".format(min_bound))
ret = clingo.clingo_main(app, args)
if app.solved:
break
min_bound += 1
for model in handle:
a = self.__theory.assignment(model.thread_id)
total_facts, bound = self.get_total_facts(a)
break
else:
non_interrupted_calls += 1
# sys.stdout.write("Optimum Found\n")
break
toc = time.time()
time_used += (toc - tic)
self.add_new_constraint(prg, bound)
else:
ret = prg.solve()
if i != 0:
makespan_time_window.append(last_bound)
i = i + 1 # Go to the next Time Window
#next_window_assignment = ''
self.generating_next_time_window(
total_facts, i
) # This call is to generate Time Window Assignment for the upcoming Window
for x in range(NUM_OF_TIME_WINDOWS):
print("Completion Time for Window {} : {} ".format(
x + 1, makespan_time_window[x]))
print("Number of interrupted calls : {} ".format(interrupted_calls))
print("Number of non-interrupted calls : {} ".format(
non_interrupted_calls - 1))
#print(sys.argv[2])
sys.exit(int(clingo.clingo_main(Application("test"), sys.argv[1:])))
def main():
setup_logger()
sys.exit(int(clingo.clingo_main(Application(), sys.argv[1:])))
