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 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 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 runtest(self): # Check solution solution: Dict[str, Any] = self.result["solution"] model = Model(self.base_dir / self.result["model"]) model["mzn_ignore_symmetry_breaking_constraints"] = True model["mzn_ignore_redundant_constraints"] = True if "data_file" in self.result and len(self.result["data_file"]) > 0: model.add_file(self.base_dir / self.result["data_file"]) status = Status[self.result["status"]] assert check_solution(model, solution, status, self.checker), "Incorrect solution" # Record that the problem is satisfiable for use in check_statuses self.user_properties.append(("sat", (self.key, True))) # Record objective for use in check_statuses if "objective" in solution: self.user_properties.append( ("objective", (self.key, solution["objective"])))
def solve(self, brick_layout: BrickLayout, verbose=True, intermediate_solutions=False, timeout=None, recompute_graph=False): if verbose: print(f"start solving by {self.solver_type} ...") start_time = time.time() model = Model() model.add_file(self.model_file) instance = Instance(self.solver, model) # add data to the solver instance = self.add_data_to_model(brick_layout, instance, recompute_graph=recompute_graph) result = instance.solve(intermediate_solutions=intermediate_solutions, timeout=timeout) if result.status.has_solution(): if intermediate_solutions: selected_nodes = [ 1 if selected else 0 for selected in result.solution[-1].node ] else: selected_nodes = [ 1 if selected else 0 for selected in result['node'] ] else: selected_nodes = np.zeros(brick_layout.node_feature.shape[0]) print("No solutions are found") if verbose: print(f"solve finished in {time.time() - start_time}") brick_layout.predict = selected_nodes return brick_layout, time.time() - start_time
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 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()
from minizinc import Instance, Model, Result, Solver, Status gecode = Solver.lookup("gecode") m = Model("mwe_pydata.mzn") m["test_param"] = 3 # this did not work #m["test_vals"] = [1, 4, 4] #m["test_len"] = 3; # this did not work either m.add_file("mwe_pydata.dzn") inst = Instance(gecode, m) result = inst.solve() print(result["x"])
from minizinc import Instance, Model, Solver import numpy as np from numpy import savetxt import sys import json chuffed = Solver.lookup("chuffed") generator = Model("./scripts/minizinc/Dominosa_final.mzn") generator.add_file("./scripts/minizinc/Dominosa.dzn") instance = Instance(chuffed, generator) # Find and print all possible solutions r = instance.solve(all_solutions=True) #m = r['temp'] #m = np.array(m,dtype=int) #n = m.shape[0] - 1 list_sol = [] for i in range(0, len(r)): list_sol.append(np.array(r[i, 'temp']).flatten()) dictionary_all_solutions = {} for index, solution in enumerate(list_sol): cont = 0 dictonary_cards = {} for i in range(1, int((len(solution) / 2) + 1)): count = 0 first = -1 for x in range(0, len(solution)): if (solution[x] == i): if (count == 0):
def getKillerSudoku(self, base, hints, seed): return KillerSudokuBoard(base, self.board,hints,seed) if __name__ == "__main__": SOLVABLE = False outputfile = "f-output4h35"#int(sys.argv[1]) base = 4 #int(sys.argv[2]) assert base > 0 hints = 35 # TODO: Seed not producing reliable results seed = 54 print("Starting Minizinc Module") gecode = Solver.lookup("gecode") model = Model() model.add_file(os.path.dirname(__file__) +"\\SudokuGeneration.mzn") model.output_type = Board instance = Instance(gecode, model) instance["Base"] = base result = instance.solve(verbose=True, debug_output=Path("./debug_output.txt")) kill_b:KillerSudokuBoard = result.solution.getKillerSudoku(base, hints, seed) print("Sudoku Generation Complete") print("Starting Cage Generation") if SOLVABLE: print("Valid") kill_b.gen_cages_valid(base*base*base) else: #Note: Sudokus obtained by the invalid process MAY be solvable, it's just not likely. print("Invalid")
import sys sys.path.append("../") from OptunaMinizinc.Tuning import Tuning from minizinc import Model, Solver, Instance tuning = Tuning() cbc = Solver.lookup("osicbc") model = Model() model.add_file("./models/mapping.mzn") instance = Instance(cbc, model) instance.add_file("./models/full2x2_mp3.dzn") tuning.load_instance(instance) tuning.load_param_from_pcs_file("../pcsFiles/osicbc.json") params = tuning.start(n_trials=50) print(params)