def gen(instance_data):
instance = Instance(Solver.lookup('gecode'), Model('gen.mzn'))
instance['n'] = instance_data['n']
instance['groups'] = instance_data['groups']
instance['rowN'] = instance_data['rowN']
instance['colN'] = instance_data['colN']
instance['pair'] = instance_data['pairs']
# results = instance.solve()
# results = instance.solve(all_solutions=True)
results = instance.solve(nr_solutions=20)
res_idx = random.randrange(0, len(results.solution))
instance_data['rowSum'] = results[res_idx, 'rowSum']
instance_data['colSum'] = results[res_idx, 'colSum']
instance_data['results'] = results[res_idx, 'results']
instance_data['rowSum'] = results[res_idx, 'rowSum']
instance_data['colSum'] = results[res_idx, 'colSum']
instance_data['results'] = [
e.tolist()
for e in array_split(results[res_idx, 'results'], instance_data['n'])
]
instance_data['results_as_digits'] = [
e.tolist() for e in array_split(
[0 if e == "Empty" else 1
for e in results[res_idx, 'results']], instance_data['n'])
]
return instance_data
def run_on_all_inputs(model_path, output_dir, input_dir=INPUT_DIR):
if not dir_exists(input_dir, label='input_dir', verbose=True):
return
if not output_dir[-1] == '/':
output_dir += '/'
os.makedirs(output_dir, exist_ok=True)
model = Model(model_path)
gecode = Solver.lookup("gecode")
input_num = 0
while not get_input(input_num) is None:
# Se l'output e' gia' stato calcolato non ricalcolo
if read_output(input_num, suppress_error=True) == None:
print("Lavoro su input num %d" % (input_num))
instance = Instance(gecode, model)
initialize_instance(instance, input_num)
result = instance.solve()
output_fpath = gen_fpath(input_num, output_dir, OUTPUT_PREFIX,
OUTPUT_EXT)
write_output(result, instance, output_fpath)
else:
print("Trovato output per input num %d. Skip" % (input_num))
input_num += 1
def run_on_all_inputs(model_path, model_type, output_dir):
if not os.path.exists(output_dir):
os.makedirs(output_dir, exist_ok=True)
if not output_dir[-1] == '/':
output_dir += '/'
fname_prefix = "output_"
fname_suffix = ".json"
model = Model(model_path)
gecode = Solver.lookup("gecode")
input_num = 0
while not get_input(input_num) is None:
instance = Instance(gecode, model)
initialize(instance, input_num)
result = instance.solve()
output_path = output_dir + fname_prefix
output_path += '{:02d}'.format(input_num)
output_path += fname_suffix
print("Lavoro su input num %d" %(input_num))
save_result(result, instance, model_type, output_path)
input_num += 1
def solve_minizinc(costs_matrix, job_demands, job_durations, num_precedences,
predecessors, successors, prec_delays, percent):
dur_max = max(job_durations)
no_intervals = no_intervals_day + (dur_max - 1) * 2
multipleDSP = Model("scripts/{}".format(minizinc_model))
gecode = Solver.lookup("gecode")
ins = Instance(gecode, multipleDSP)
max_demand = int(sum(job_demands) * percent)
ins["no_intervals"] = no_intervals
ins["no_devices"] = len(costs_matrix)
ins["durations"] = job_durations
ins["demands"] = job_demands
ins["num_precedences"] = num_precedences
ins["predecessors"] = predecessors
ins["successors"] = successors
ins["prec_delays"] = prec_delays
ins["max_demand"] = max_demand
ins["run_costs"] = costs_matrix
result = ins.solve()
cp_astarts_temp = result["actual_starts"]
cp_astarts = [(astart - dur_max + 1) % no_intervals_day
for astart in cp_astarts_temp]
#
# actual_start = (chosen_index - dur + 1) % no_intervals_day
return cp_astarts
def main():
f = open("bin/resources/in", "r")
fout = open("bin/resources/out", "w")
size = int(f.readline())
given = []
for _ in range(size):
given.append(
[int(x) if x != 'N' else None for x in f.readline().split()])
f.close()
model = Model("src/resources/minizinc/Binairo.mzn")
chuffed = Solver.lookup("chuffed")
instance = Instance(chuffed, model)
instance['size'] = size
instance['given'] = given
result = instance.solve()
if not result:
print('NO SOLUTION!')
else:
solution = result['matrix']
for line in solution:
for x in line:
fout.write(str(x) + " ")
fout.write("\n")
fout.close()
class InstanceTestCase(unittest.TestCase):
code = ""
instance: GenInstance
solver: Solver
def setUp(self):
self.solver = Solver.lookup("gecode")
self.instance = Instance(self.solver)
self.instance.add_string(self.code)
def main():
file_instances = [
f for f in listdir(path_dzn)
if isfile(join(path_dzn, f)) and f.endswith(".dzn")
]
print(sorted(file_instances))
instance_choose_name = str(
input("\n\nChoose an instance: [without the extension]\n"))
instance_choose = instance_choose_name + ".dzn"
while instance_choose not in file_instances:
instance_choose_name = str(
input(
"\nWrong choice.\nChoose an instance: [without the extension]\n"
)) #"08x08"
instance_choose = instance_choose_name + ".dzn"
user_rotation = str(
input("\n\nDo yo want to use rotation: [Y/N]\n")).upper()
while user_rotation not in ["Y", "N"]:
user_rotation = str(
input("\nWrong choice.\nDo yo want to use rotation: [Y/N]\n")
).upper()
print("Building the Model...")
gecode = Solver.lookup("gecode")
model = Model()
if user_rotation == "Y":
model.add_file("CP/OptimizationProjectRotation.mzn")
path_solution_choosen = path_solution_rot
user_rotation = True
else:
model.add_file("CP/OptimizationProject.mzn")
path_solution_choosen = path_solution
user_rotation = False
model.add_file(path_dzn + instance_choose)
instance = Instance(gecode, model)
print("Solving...")
all_sol = False
counter_solutions = 10
if all_sol:
result = instance.solve(nr_solutions=counter_solutions)
print("Stats")
print(result.statistics)
print_solution(result, user_rotation=user_rotation)
else:
result = instance.solve(all_solutions=False)
write_solution(path_solution_choosen, instance_choose_name,
str(result.solution))
print_solution(result, 1, user_rotation=user_rotation)
print("Stats")
print(result.statistics)
def minizinc(*files, solver=gecode, data={}, all_solutions=False):
"""Solve using minizinc."""
model = Model(files)
instance = Instance(solver, model)
for key, value in data.items():
if isinstance(value, str):
instance.add_string(f'{key} = {value};\n')
else:
instance[key] = value
return instance.solve(all_solutions=all_solutions)
def cp_solving(vehicle_count, vehicle_capacity, customer_count, customers, fraction=0.1):
model_vrp = Model("./vrp.mzn")
# Find the MiniZinc solver configuration for Gecode
solver = Solver.lookup("chuffed")
instance = Instance(solver, model_vrp)
instance["nb_customers_without_depot"] = customer_count-1
nb_customers_virtual = customer_count-1+vehicle_count+1
range_customer_virtual = range(1, nb_customers_virtual+1)
instance["nb_vehicle"] = vehicle_count
closest, matrix = compute_length_matrix(customers)
demands = [customers[i].demand for i in range(1, customer_count)]+[0]*(vehicle_count+1)
instance["demand"] = demands
instance["capacity_vehicle"] = vehicle_capacity
recomputed_dist = []
for i in range(1, customer_count):
recomputed_dist += [[int(matrix[i, j]) for j in range(1, customer_count)]+[int(matrix[i, 0])]*(vehicle_count+1)]
for v in range(vehicle_count+1):
recomputed_dist += [[int(matrix[0, j]) for j in range(1, customer_count)]+[0]*(vehicle_count+1)]
instance["distance"] = recomputed_dist
result = instance.solve(timeout=timedelta(seconds=100))
opt: Status = result.status
print(result.__dict__)
objective = result["objective"]
print("Objective : ", objective)
print(result["circuit_vrp"])
iteration = 0
dict_result = {i+1: result["circuit_vrp"][i] for i in range(nb_customers_virtual)}
current_objective = objective
while iteration < 1000:
with instance.branch() as child:
subpart_tsp = set(random.sample(range_customer_virtual, int(fraction*len(range_customer_virtual))))
for i in range_customer_virtual:
if i not in subpart_tsp:
# print("constraint color_graph["+str(i)+"] == "+ str(dict_color[i])+";\n")
child.add_string("constraint circuit_vrp["+str(i)+"] == "+ str(dict_result[i])+";\n")
child.add_string(f"solve minimize(objective);\n")
res = child.solve(timeout=timedelta(seconds=50))
print(res.status)
if res.solution is not None and res["objective"] <= current_objective:
iteration += 1
incumbent = res.solution
current_objective = res["objective"]
dict_result = {i+1: res["circuit_vrp"][i] for i in range(nb_customers_virtual)}
#json.dump(dict_color, open('debug_cp.json', "w"))
print(iteration , " : , ", res["objective"])
print('IMPROVED : ', iteration)
print("dict result : ", dict_result)
else:
try:
print("Not improved ")
print(iteration , " : ", res["objective"])
except:
print(iteration, " failed ")
# print({i: res["color_graph"][i-1] for i in range_node})
iteration += 1
def test_toy_minizinc():
model = Model()
model.add_string('''
var -2..2: a;
constraint a < 0;
solve satisfy;
''')
gecode = Solver.lookup("gecode")
inst = Instance(gecode, model)
result = inst.solve(all_solutions=True)
print([{"a": result[i, "a"]} for i in range(len(result))])
def call_minizinc(model_file, n, l, k):
# The supplied MIP solver doesn't support the "all_solutions"
# flag, so we must use a CP solver. It's still about 2x faster
# to use a MIP-style model, though.
solver = Solver.lookup("chuffed")
model = Model(model_file)
instance = Instance(solver, model)
instance["N"] = n
instance["L"] = l
instance["K"] = k
return instance.solve(all_solutions=True)
def test_assign(self):
self.instance = Instance(self.solver)
self.instance.add_string("""
enum TT;
var TT: t1;
""")
TT = enum.Enum("TT", ["one"])
self.instance["TT"] = TT
result = self.instance.solve()
assert isinstance(result["t1"], TT)
assert result["t1"] is TT.one
def run_on_input(model_path, input_num, input_dir=INPUT_DIR):
if not dir_exists(input_dir, label='input_dir', verbose=True):
return
# TODO try catch
model = Model(model_path)
gecode = Solver.lookup("gecode")
instance = Instance(gecode, model)
initialize_instance(instance, input_num)
result = instance.solve()
show_result(result, instance)
class TestEnum(InstanceTestCase):
code = """
enum DAY = {Mo, Tu, We, Th, Fr, Sa, Su};
var DAY: d;
"""
def test_value(self):
self.instance.add_string("constraint d == Mo;")
result = self.instance.solve()
assert isinstance(result["d"], str)
assert result["d"] == "Mo"
def test_cmp_in_instance(self):
self.instance.add_string("var DAY: d2;")
self.instance.add_string("constraint d < d2;")
result = self.instance.solve()
assert isinstance(result["d"], str)
assert isinstance(result["d2"], str)
# TODO: assert result["d"] < result["d2"]
def test_cmp_between_instances(self):
append = "constraint d == Mo;"
self.instance.add_string(append)
result = self.instance.solve()
inst = Instance(self.solver)
inst.add_string(self.code + append)
result2 = inst.solve()
assert isinstance(result["d"], str)
assert isinstance(result2["d"], str)
assert result["d"] == result2["d"]
inst = Instance(self.solver)
inst.add_string("""
enum DAY = {Mo, Tu, We, Th, Fr};
var DAY: d;
""" + append)
result2 = inst.solve()
# TODO: assert type(result["d"]) != type(result2["d"])
# TODO: assert result["d"] == result2["d"]
def test_assign(self):
self.instance = Instance(self.solver)
self.instance.add_string("""
enum TT;
var TT: t1;
""")
TT = enum.Enum("TT", ["one"])
self.instance["TT"] = TT
result = self.instance.solve()
assert isinstance(result["t1"], TT)
assert result["t1"] is TT.one
def main():
file_instances = sorted([
f for f in listdir(path_dzn)
if isfile(join(path_dzn, f)) and f.endswith(".dzn")
])
user_rotation_str = str(
input("\n\nDo yo want to use rotation: [Y/N]\n")).upper()
while user_rotation_str not in ["Y", "N"]:
user_rotation_str = str(
input("\nWrong choice.\nDo yo want to use rotation: [Y/N]\n")
).upper()
print("Building the Model...")
gecode = Solver.lookup("gecode")
count_iter = 0
solv_times = []
while (count_iter < len(file_instances)):
model = Model()
if user_rotation_str == "Y":
model.add_file("CP/OptimizationProjectRotation.mzn")
path_solution_choosen = path_solution_rot
user_rotation = True
else:
model.add_file("CP/OptimizationProject.mzn")
path_solution_choosen = path_solution
user_rotation = False
instance_choose = file_instances[count_iter]
model.add_file(path_dzn + instance_choose)
instance = Instance(gecode, model)
print("Solving instance: {}".format(instance_choose))
result = instance.solve(all_solutions=False)
#write_solution(path_solution_choosen, instance_choose.split('.')[0], str(result.solution))
#print_solution(result, 1, user_rotation=user_rotation)
print("Solving Time")
print(result.solution)
print(result.statistics)
print(result.statistics['solveTime'])
solv_times.append(result.statistics['solveTime'].total_seconds())
count_iter += 1
fig = plt.figure()
plt.plot(range(8, len(solv_times) + 8), solv_times, 'bo')
plt.yscale('log')
# beautify the x-labels
plt.xlabel("Instances")
plt.ylabel("Solve Time (sec)")
plt.show()
def elegantly_color(graph: AdjMatrix) -> Tuple[AdjMatrix, List[int]]:
"""Return an adjacency matrix represnting elegantly colored edges."""
model_path = MIZNIZIC_MODELS_DIR.joinpath("elegant_labeling.mzn")
model = Model(model_path)
instance = Instance(Solver.lookup("gecode"), model)
instance["graph"] = graph
instance["total_edges"] = count_edges(graph)
instance["total_vertices"] = len(graph)
result = instance.solve()
if (status := result.status) != Status.SATISFIED:
error = f"An error occured when coloring the graph. Returned status: {status}"
raise RuntimeError(error)
def run_extended(self):
inst = Instance(self.solver, self.model)
# we'll need a solution pool of previously seen solutions
# to rule out condorcet cycles; a solution is stored as a Python dictionary from variable to value
solution_pool = []
res: Result = inst.solve()
print(res.solution)
duels = []
new_solution = None
model_counter = 0
while res.status == Status.SATISFIED:
model_counter += 1
old_solution = new_solution
new_solution = {
var: res[var]
for var in self.variables_of_interest
}
solution_pool += [new_solution]
if hasattr(res.solution, PREFERRED_BY_KEY):
preferred_by = res[PREFERRED_BY_KEY]
self.num_voters = res[NUM_VOTERS_KEY]
print(preferred_by)
duels += [(new_solution, old_solution, preferred_by)]
with inst.branch() as child:
child.add_string(
f"array[{self.agents_key}] of par int: old_score;")
child["old_score"] = res["score"] # copy the current ranks
self.add_condorcet_improvement(child)
self.add_duel_bookkeeping(child)
# but it should be a "new" solution
self.post_something_changes(child, solution_pool)
# logging
self.log_and_debug_generated_files(child, model_counter)
res = child.solve()
if res.solution is not None:
print(res.solution)
for (winning_solution, losing_solution, preferrers) in duels:
print(
f"Solution {winning_solution} won against {losing_solution} with {preferrers} : {self.num_voters - preferrers}"
)
def do_POST(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length).decode('utf-8')
body = json.loads(body)
# print(body)
# Load n-Queens model from file
model = Model("../../Modelo Minizinc/PlantaEnergia.mzn")
#Create data file
writeInstace(body)
#add data file
model.add_file("Datos.dzn")
# Find the MiniZinc solver configuration for Gecode
gecode = Solver.lookup("coin-bc")
# Create an Instance of the n-Queens model for Gecode
instance = Instance(gecode, model)
#Execute minizinc
result = instance.solve()
# Output the array q
if result.solution is None:
responseData = {'satisfactible': False}
else:
# Respuesta
responseData = {
'satisfactible': True,
"N": result["PN"],
"H": result["PH"],
"T": result["PT"],
"Objective": result["objective"]
}
print(responseData)
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Content-Type', 'application/json')
self.end_headers()
response = BytesIO()
jsonData = json.dumps(responseData)
binaryData = jsonData.encode()
response.write(binaryData)
self.wfile.write(response.getvalue())
def test_intenum_collections(self):
self.instance = Instance(self.solver)
self.instance.add_string("""
enum TT;
% array[int] of var TT: arr_t;
var set of TT: set_t;
""")
TT = enum.IntEnum("TT", ["one", "two", "three"])
self.instance["TT"] = TT
# TODO: self.instance["arr_t"] = [TT(3), TT(2), TT(1)]
self.instance["set_t"] = {TT(2), TT(1)}
result = self.instance.solve()
# TODO: assert result["arr_t"] == [TT(3), TT(2), TT(1)]
assert result["set_t"] == {TT(1), TT(2)}
def minizincSolverNew(file, model):
games = Model(model)
games.add_file(file)
gecode = Solver.lookup('gecode')
instance = Instance(gecode, games)
result = instance.solve()
token = None
play = None
total_fun = None
sat = result.status
time = result.statistics['time'].total_seconds()
if result.status.has_solution():
token = result['token']
play = result['play']
total_fun = re.search(r'\d+', str(result.solution)).group()
return [sat, token, play, total_fun, time]
def test_python_data_input_model_strict(self):
start_model = Model()
start_model.add_file(
options.DIRECTORY +
"algorithms/voting_mechanisms/pref_profile_pure_model.mzn")
start_inst = Instance(self.gecode, start_model)
start_inst["n_vote_templates"] = len([5, 7, 4, 3, 3, 2])
start_inst["templateCardinalities"] = [5, 7, 4, 3, 3, 2]
start_inst["n_options"] = 4
start_inst["prefTemplates"] = [
[1, 3, 4, 2],
[2, 4, 1, 3],
[1, 4, 3, 2],
[3, 4, 2, 1],
[4, 3, 1, 2],
[4, 3, 2, 1],
]
condorcet_runner = CondorcetRunner(start_model, self.gecode,
self.variables_of_interest,
AGENTS_KEY, AGENTS_PREFERS_KEY,
False)
condorcet_runner.inst = start_inst
sol = condorcet_runner.run_basic()
# We should see: A, B, C, D
self.assertEqual(4, sol["control"], "D should be Condorcet winner")
self.assertEqual(2, len(condorcet_runner.all_solutions),
"We should have seen two solutions in the process.")
actual_control_values = [
sol["control"] for sol in condorcet_runner.all_solutions
]
expected_control_values = [1, 4]
self.assertListEqual(actual_control_values, expected_control_values,
"Should be that stream of solutions")
def to_solve(self):
from minizinc import Instance, Model, Solver
seaux = Model("./seaux.mzn")
gecode = Solver.lookup("gecode")
instance = Instance(gecode, seaux)
instance["N"] = len(self.buckets)
instance["init"] = [b.current for b in self.buckets]
instance["storage"] = [b.capacity for b in self.buckets]
instance["goal"] = [b.goal for b in self.buckets]
result = instance.solve()
if result is not None:
print(result)
#QMessageBox.information(self, "Solution", f"Le problème peut être résoulu en {result['total_steps']}")
self.move_auto(result["transfered"], result["total_steps"] - 1)
else:
QMessageBox.information(self, "Solution",
f"Le problème est insoluble")
def auto(self):
from minizinc import Instance, Model, Solver
mouton = Model("./mouton.mzn")
gecode = Solver.lookup("gecode")
instance = Instance(gecode, mouton)
instance["N"] = len(self.sheeps) // 2
if instance["N"] == 1:
instance["max_steps"] = 4
elif instance["N"] == 2:
instance["max_steps"] = 9
else:
instance["max_steps"] = 16
result = instance.solve()
if result is not None:
self.move_auto(result["transfered"])
else:
QMessageBox.information(self, "Solution",
f"Le problème est insoluble")
def test_cmp_between_instances(self):
append = "constraint d == Mo;"
self.instance.add_string(append)
result = self.instance.solve()
inst = Instance(self.solver)
inst.add_string(self.code + append)
result2 = inst.solve()
assert isinstance(result["d"], str)
assert isinstance(result2["d"], str)
assert result["d"] == result2["d"]
inst = Instance(self.solver)
inst.add_string("""
enum DAY = {Mo, Tu, We, Th, Fr};
var DAY: d;
""" + append)
result2 = inst.solve()
def solver(data):
"""
Ejecucion del modelo en minizinc
"""
# Configurar modelo y solver
planta_energia = Model("./model/PlantaEnergia.mzn")
coinbc = Solver.lookup("coin-bc")
instance = Instance(coinbc, planta_energia)
# Configurar parametros de entrada
instance["n"] = data['n']
instance["s"] = data['s']
instance["CP"] = data['CP']
instance["CC"] = data['CC']
instance["d"] = data['d']
# Resultado modelo
result = instance.solve()
print("Resultado MiniZinc:", result)
return result
def solve():
times, n = prep_data()
nqueens = Model("./model.mzn")
# Find the MiniZinc solver configuration for Gecode
solver = Solver.lookup("chuffed")
# Create an Instance of the n-Queens model for Gecode
instance = Instance(solver, nqueens)
# Assign 4 to n
instance["N_slot"] = n
instance["min_time"] = 0
instance["max_time"] = 7 * 60 * 24
instance["max_duration_meeting"] = max([s[1] - s[0] + 1 for s in times])
instance["duration_meeting"] = 59
instance["array_meeting"] = [s[0] for s in times]
instance["array_duration"] = [s[1] - s[0] + 1 for s in times]
from datetime import timedelta
result = instance.solve(timeout=timedelta(seconds=3600))
# Output the array q
opt: Status = result.status
print(result.__dict__)
time = result["time_meeting"]
beg = time
end = time + 59
day = (beg - 1) // 600
hour = ((beg - 1 - (day * 600)) // 60)
minute = beg - 1 - (day * 600) - (hour * 60)
houre = ((end - 1 - (day * 600)) // 60)
minutee = end - 1 - (day * 600) - (houre * 60)
def countToString(hour):
if hour < 10:
return "0" + str(hour)
else:
return str(hour)
print(
str(day + 1) + " " + countToString(hour + 8) + ":" +
countToString(minute) + "-" + countToString(houre + 8) + ":" +
countToString(minutee))
def __platform_selected(self):
"""
The paltform selected method intialises the solver, create a instance and pass appropriate varibles values.
Insatnce is solved and results are appended to appropriate variable.
Returns the selected platform from minizinc that solves CSP.
Parameters
----------
**params:
None
Returns
-------
platform_solutions: list
Contains all the solution obtained from the CSP solver.
"""
# Load platfroms model from file
minizinc_file = "./" + str(self.__minizinc_model)
platforms = Model(minizinc_file)
# Find the MiniZinc solver configuration for Gecode
gecode = Solver.lookup("gecode")
# Create an Instance of the platforms model for Gecode
instance = Instance(gecode, platforms)
instance["force_sensor_presence"] = self.__repo_image.force_sensor_presence
instance["min_tactile_sensor_count"] = self.__repo_image.min_tactile_sensor_count
instance["min_memory_fused"] = self.__repo_image.min_memory_fused
instance["n_platforms"] = self.__repo_image.n_platforms
instance["platforms"] = self.__repo_image.platforms
instance["min_latency"] = self.__repo_image.fused_platform_min_latency
instance["max_latency"] = self.__repo_image.fused_platform_max_latency
instance["req_force_plfm_type"] = self.__repo_image.force_sensor_type
instance["curr_memory_availability"]= [int(x) for x in self.__repo_image.platforms_memory_availability]
result = instance.solve(intermediate_solutions=True)
platform_solutions = []
if len(result) != 0:
for i in result:
platform_solutions.append(i.force_platform)
platform_solutions.append(i.tactile_platform)
platform_solutions.append(i.fused_platform)
return platform_solutions
def present_wrapping_problem():
model_path = "src/Project.mzn"
pwp = Model(model_path)
instances_directory = "src/Instances"
gecode = Solver.lookup("gecode")
all_files = os.listdir(instances_directory)
os.close
for instance_file in all_files:
instance = Instance(gecode, pwp)
with open(instances_directory + "/" + instance_file, "r") as file:
solve_instance(instance, file)
async def explore_async(self,
decision_model,
backend_solver_name='gecode'):
mzn_model_name = decision_model.get_mzn_model_name()
mzn_model_str = res.read_text('idesyde.minizinc', mzn_model_name)
mzn_model = Model()
mzn_model.add_string(mzn_model_str)
backend_solver = Solver.lookup(backend_solver_name)
instance = Instance(backend_solver, mzn_model)
decision_model.populate_mzn_model(instance)
result = await instance.solve_async()
return decision_model.rebuild_forsyde_model(result)
def minimum_set_cover_mz(problem):
with path('mz_python_puzzles.setcover.mz', 'setcover.mzn') as model_path:
model = Model(model_path)
solver = Solver.lookup('org.minizinc.mip.coin-bc')
instance = Instance(solver, model)
instance['N'] = len(problem.universe)
instance['M'] = len(problem.sets)
instance['cost'] = list(map(lambda s: s.cost, problem.sets))
instance['items_covered'] = (
list(map(lambda s: set(map(lambda i: i + 1, s.items)), problem.sets))
)
result = instance.solve(timeout=timedelta(seconds=5))
if result.status.has_solution():
return Cover(
result.objective,
[problem.sets[i] for i, s in enumerate(result.solution.chosen)
if s == 1]
)
return None
