def getSolution(equation): Solver.throwIfAIsZero(equation) a = equation.get("a") b = equation.get("b") return f"x = {Solver.parseFraction(-b, a)}"
def main(): folder = config.FOLDER_NAME if not os.path.exists('./%s' % folder): os.makedirs('./%s' % folder) if not os.path.exists('./%s/models' % folder): os.makedirs('./%s/models/' % folder) if not os.path.exists('./%s/logs' % folder): os.makedirs('./%s/logs/' % folder) if os.path.exists('./%s/vdict.json' % folder) and os.path.exists( './%s/adict.json' % folder): print 'restoring vocab' with open('./%s/vdict.json' % folder, 'r') as f: question_vocab = json.load(f) with open('./%s/adict.json' % folder, 'r') as f: answer_vocab = json.load(f) else: question_vocab, answer_vocab = make_vocab_files() with open('./%s/vdict.json' % folder, 'w') as f: json.dump(question_vocab, f) with open('./%s/adict.json' % folder, 'w') as f: json.dump(answer_vocab, f) print 'question vocab size:', len(question_vocab) print 'answer vocab size:', len(answer_vocab) with tf.variable_scope(config.MODEL_SCOPE): model = CapsAtt() solver = Solver(model) solver.train()
def __init__(self, iters=6000, test='temp', full=True, L=True, OD=True, CP=True, LP=True, eq='CP', init=False, noise=0, method='py_oracle'): Solver.__init__(self, test=test, full=full, L=L, OD=OD, CP=CP, LP=LP, eq=eq, init=init, noise=noise, method=method) self.iters = iters # CS test config self.CS_PATH = '/Users/cathywu/Dropbox/Fa13/EE227BT/traffic-project' self.OUT_PATH = '%s/' % c.DATA_DIR # Test parameters # self.method = 'cvx_random_sampling_L1_30_replace' # self.method = method # 'cvx_random_sampling_L1_6000_replace' # self.method = 'cvx_oracle' # alg = 'cvx_unconstrained_L1' # alg = 'cvx_L2' # alg = 'cvx_raw' # alg = 'cvx_weighted_L1' # alg = 'cvx_hot_start_lp' # alg = 'cvx_single_block_L_infty' # alg = 'cvx_random_sample_L_infty' # alg = 'cvx_mult_blocks_L_infty' # alg = 'cvx_block_descent_L_infty' # alg = 'cvx_entropy' self.A, self.b, self.N, self.block_sizes, self.x_true, self.nz, \ self.flow, self.rsort_index, self.x0 = None, None, None, None, \ None, None, None, None, None self.fname, self.mlab = None, None
def solve(): sets=[] # The variable 'sets' stores multiple problem sets. # Each problem set comes from a different folder in /Problems/ # Additional sets of problems will be used when grading projects. # You may also write your own problems. r = open(os.path.join("Problems","ProblemSetList.txt")) # ProblemSetList.txt lists the sets to solve. line = getNextLine(r) # Sets will be solved in the order they appear in the file. while not line=="": # You may modify ProblemSetList.txt for design and debugging. sets.append(ProblemSet(line)) # We will use a fresh copy of all problem sets when grading. line=getNextLine(r) # We will also use some problem sets not given in advance. # Initializing problem-solving agent from Solver.java agent=Solver() # Your agent will be initialized with its default constructor. # You may modify the default constructor in Solver.java # Running agent against each problem set with open("AgentAnswers.csv","w") as results: # Results will be written to ProblemResults.csv. # Note that each run of the program will overwrite the previous results. # Do not write anything else to ProblemResults.txt during execution of the program. results.write("ProblemSet,RProblem,Solver's Answer\n") for set in sets: for problem in set.problems: # Your agent will solve one problem at a time. #try: answer = agent.Solve(problem) # The problem will be passed to your agent as a RProblem object as a parameter to the Solve method # Your agent should return its answer at the conclusion of the execution of Solve. results.write("%s,%s,%d\n" % (set.name, problem.name, answer)) r.close()
def pluck(puzzle, cardinality): # prepare our solver and context solver = Solver(puzzle) context = Context() solver.assert_rules(context) # start with a set of all 81 cells, and tries to remove one (randomly) at a time # but not before checking that the cell can still be deduced from the remaining cells. cells = set(range(81)) cells_remaining = cells.copy() while len(cells) > cardinality and len(cells_remaining) != 0: cell = random.choice(list(cells_remaining)) cells_remaining.discard(cell) row, column = cell // 9, cell % 9 val = puzzle.get_cell(row, column) assert val is not None if solver.erasable(context, row, column, val): puzzle.erase_cell(row, column) cells.discard(cell) context.dispose() return (puzzle, len(cells))
def main(): dataset=dataloader.prepare_test_dataset() with tf.variable_scope(config.VQA_SCOPE): model=CapsVQA(mode='test') model.build_vqa_module() solver=Solver(model,dataset) solver.visulize_att_lists()
def __init__(self, name="solverlinear"): """ Constructor. """ Solver.__init__(self, name) ModuleSolverLinear.__init__(self) return
def mkgoodtrain(): wps = open("../all_a.txt").readlines() answs = open("../all_aa.txt").readlines() goodtrain = open("goodp.txt",'w') goodtraina = open("gooda.txt",'w') for k in range(len(wps)): print(k) problem = wps[k].lower() try: story = nlp.parse(problem) numbs = setmaker.setmaker(story) numlist = [cleannum(v.num) for k,v in numbs if setmaker.floatcheck(v.num)] numlist = [x for x in numlist if x!=''] except: continue print(numlist) signal.signal(signal.SIGALRM, kill) signal.alarm(10) try: ST = Solver(numlist) answers = ST.solveEquations(float(answs[k])) print(answers) except: continue if answers != []: goodtrain.write(problem) goodtraina.write(answs[k]) goodtrain.close();goodtraina.close()
def run(self): while True: html = self.opener.open(captcha_url).read().decode() captcha_img_url = host + pq(html)("#captcha_image").attr("src") captcha_img = self.opener.open(captcha_img_url).read() try: solver = Solver(Image.open(BytesIO(captcha_img)), captcha_length) result = solver.get_result() if len(solver.char_areas) != captcha_length: raise IndexError() except IndexError: self.queue.put( (Image.open(BytesIO(captcha_img)), Image.open(BytesIO(captcha_img)), "------", False, True)) continue payload = { "do": "contact", "ct_name": "", "ct_email": "", "ct_URL": "", "ct_message": "", "ct_captcha": result } resp = self.opener.open(captcha_url, urlencode(payload).encode()).read().decode() print("put!") img_data = { 'pixels': solver.captcha.tobytes(), 'size': solver.captcha.size, 'mode': solver.captcha.mode, } if "captcha was correct" in resp: self.queue.put((Image.open(BytesIO(captcha_img)), img_data, result, True, False)) print('Corr') else: self.queue.put((Image.open(BytesIO(captcha_img)), img_data, result, False, False)) print('Wong')
def main(): folder = config.FOLDER_NAME if not os.path.exists('./%s' % folder): os.makedirs('./%s' % folder) question_vocab, answer_vocab = {}, {} if os.path.exists('./%s/vdict.json' % folder) and os.path.exists( './%s/adict.json' % folder): print 'restoring vocab' with open('./%s/vdict.json' % folder, 'r') as f: question_vocab = json.load(f) with open('./%s/adict.json' % folder, 'r') as f: answer_vocab = json.load(f) else: question_vocab, answer_vocab = make_vocab_files() with open('./%s/vdict.json' % folder, 'w') as f: json.dump(question_vocab, f) with open('./%s/adict.json' % folder, 'w') as f: json.dump(answer_vocab, f) print 'question vocab size:', len(question_vocab) print 'answer vocab size:', len(answer_vocab) with tf.variable_scope(config.VQA_SCOPE): model = Baseline(mode='val') solver = Solver(model) solver.eval()
def login(): b.get(LOGIN_URL) solver = None while True: elem = b.find_element_by_id('verifyImg') location = elem.location size = elem.size x = int(location['x'] * CHROME_UI_SCALE) y = int(location['y'] * CHROME_UI_SCALE) width = x + int(size['width'] * CHROME_UI_SCALE) height = y + int(size['height'] * CHROME_UI_SCALE) buffer = BytesIO(b.get_screenshot_as_png()) img = Image.open(buffer) img = img.crop(( x, y, width, height, )) solver = Solver(img, 4) if len(solver.char_areas) == 4: break b.find_element_by_css_selector('a.apply:nth-child(1)').click() print('Refreshing captcha', len(solver.char_areas)) sleep(1) b.find_element_by_id('checkCode').send_keys(solver.get_result()) b.find_element_by_id('username').send_keys(USERNAME) b.find_element_by_id('password').send_keys(PASSWORD) b.find_element_by_css_selector( '#loginbox-nav > a:nth-child(1)').click() if 'IJ0305' in b.page_source: # Wrong captcha login()
def __init__(self, name, facility="solver"): Solver.__init__(self, name, facility) self.coupler = None self.myPlus = [] self.remotePlus = [] return
def checkpoint(self, checkpointFrequency): Solver.checkpoint(self, checkpointFrequency) if not (self.step % checkpointFrequency): #TODO: checkpoint for coupler pass return
def Ex3h(n, T, planet_names, save_plot=False): """ n : Integration points T : Time to run the simulation. planet_names : Import of wanted planets (and/or Sun) """ #n = int(1e5) planets = SolarSystem(planet_names) Np = len(planets.mass) # Nr. of planets init_pos = planets.initPos init_vel = planets.initVel masses = planets.mass # Using the class solver = Solver(masses, init_pos, init_vel, Np, T, n) pos_V, vel_V, t_V = solver.solve(method="Verlet", SunInMotion=True) # Plot orbits for i in range(Np): plt.plot(pos_V[0, :, i], pos_V[1, :, i], label="%s" % planet_names[i]) plt.plot(pos_V[0, 0, i], pos_V[1, 0, i], "kx", label="Init. pos. %s" % planet_names[i]) # Make figure Figure_noSunPlot(title="Solar system. Over %g years \n Verlet method" % (T)) if save_plot == True: plt.savefig("Results/3h_solar_system_nrPlanets_%g.png" % Np) plt.show()
def solveWithAE(self): print("Algoritm evolutiv ...\n") bestAcc = -1 for i in range(1): acc = 0 new_in = self.getFromFileTest() new_out = self.getOutFromFileTest() labels = self.getLabels() print("Clase: ", labels) solver = Solver(self.getFromFileInput(), self.getFromFileOut(), labels) for index in range(len(new_in)): y_guess, prob = solver.runEvolutionaryAlgorithm(new_in[index]) y_real = new_out[index][0] print("Prezis: ", y_guess, " (probabilitatea: ", prob, ")") print("Real: ", y_real) if (y_guess == y_real): acc = acc + 1 if acc / len(new_in) > bestAcc: bestAcc = acc / len(new_in) print("Next ") print("Acuratete locala: ", acc / len(new_in)) print("Acuratete: ", str(0.6433333333333333))
def load_partial(self): input_file = str(input("Ingrese la ruta del dump de entrada: ")) output_file = str(input("Ingrese la ruta del archivo de salida: ")) file_handler = FileHandler(input_file, output_file) results = {} try: file_handler.load_boards_file_dump() for key in range(file_handler.boards_count): board = Board(file_handler.get_board(key)) solver = Solver(board, callback=self.show_solution_callback) solver.solve() results.setdefault(key, solver.solutions) except FileNotFoundError: print("No se encontró el archivo especificado") self.display_menu() except KeyboardInterrupt: dump_name = datetime.datetime.now().strftime( "%Y-%b-%d_%H-%M-%S") + ".save" self.save_partial(file_handler, results, dump_name) print("Se ha interrumpido la ejecución, dump guardado en %s" % dump_name) exit(0) file_handler.write_results_to_file(results) print("Ha finalizado la resolución! encontrará en %s los resultados" % output_file)
def fit(self, X, y): solver = Solver(self.param, X, y) model = solver.solve() self.alpha = model.alpha self.b = -model.rho if self.param.kernel_type is 'Linear': self.w = np.dot(X.T, self.alpha * y)
def getSolution(equation): Solver.throwIfAIsZero(equation) a = equation.get("a") b = equation.get("b") c = equation.get("c") delta = pow(b, 2) - (4 * a * c) if delta > 0: x1 = Solver.parseFraction(-b + math.sqrt(delta), 2 * a) x2 = Solver.parseFraction(-b - math.sqrt(delta), 2 * a) return f"x1 = {x1}, x2 = {x2}" elif delta == 0: x = Solver.parseFraction(-b, 2 * a) print("Your function is equivalent to " + QuadraticSolver.getShortMultiplicationFormulaString({ "a": a, "p": -x })) return f"x = {x}" else: return f"Rozwiązanie nie istnieje, ponieważ delta = {Solver.parseIntOrReturn(delta)}"
class MyTestCase(unittest.TestCase): def setUp(self): self.solver = Solver() def test_is_face_solved(self): self.assertEqual(True, self.solver.is_face_solved(self.solver.grids[0])) def test_is_cube_solved(self): self.assertTrue(self.solver.is_cube_solved()) def test_is_cross_solved(self): self.assertTrue(self.solver.is_cross_solved(self.solver.grids[0])) def test_color__pos_grid(self): self.assertEqual( [[[(-1 + j, 1, -1 + i) for j in range(3)] for i in range(3)], [[(-1 + j, 1 - i, 1) for j in range(3)] for i in range(3)], [[(1, 1 - i, 1 - j) for j in range(3)] for i in range(3)], [[(1 - j, 1 - i, -1) for j in range(3)] for i in range(3)], [[(-1, 1 - i, -1 + j) for j in range(3)] for i in range(3)], [[(-1 + j, -1, -1 + i) for j in range(3)] for i in range(3)]], [ self.solver.grids[0].colorposgrid, self.solver.grids[1].colorposgrid, self.solver.grids[2].colorposgrid, self.solver.grids[3].colorposgrid, self.solver.grids[4].colorposgrid, self.solver.grids[5].colorposgrid ])
def __init__(self, name="solverlinear"): """ Constructor. """ Solver.__init__(self, name) ModuleSolverLumped.__init__(self) return
def setUp(self): params = { "edgelist_path" : "./test/edgelist.txt", "symbolic": True } self.params = params self.solver = Solver(params)
def main(input_dir=None): # Input the faces of the Cube if input_dir is None: captured_faces, captured_imgs = capture_faces() else: input_imgs = load_imgs_from_dir(input_dir) captured_faces, captured_imgs = capture_faces_from_images(input_imgs) # Get the color classifier clf_yuv = get_classifier() # Predict the face colors from the input images faces = np.array(captured_faces) pred_colors_yuv, pred_proba_yuv = label_images(clf_yuv, [faces]) colors_cube = np.array(pred_colors_yuv).reshape((6, 3, 3)) # Inspect / adjust results if necessary. This step can modify pred_colors_yuv2. check_images(captured_imgs, captured_faces, colors_cube, clf_yuv) plt.show() # Define the cube using the updated colors c = Cube(colors_cube) # Solve and retain moves initial_state = c.export_state() s = Solver(c) s.solve() solve_moves = c.recorded_moves # Display the solution sg = SolutionGallery(initial_state, solve_moves) plt.show()
def __init__(self,node_set): self.node_set=node_set #Initialize all the variables Initialization.Initialization(self.node_set) self.solver=Solver(self.node_set)
def __init__(self, name="solvernonlinear"): """ Constructor. """ Solver.__init__(self, name) ModuleSolverNonlinear.__init__(self) return
def __init__(self, lobby_data, settings): self.settings = settings self.DIFFICULTY = lobby_data["difficulty"] self.SHOW_SOLVE = lobby_data["show-solve"] self.loop_running = True self.sudoku_surface = pygame.Surface((self.settings.SUDOKU_WIDTH, self.settings.SUDOKU_HEIGHT)) self.SudokuGenerator = SudokuGenerator() self.SudokuGenerator.generate_board() for row in self.SudokuGenerator.grid: print(row) self.SudokuGenerator.remove_values(self.DIFFICULTY) self.get_grid_dict() self.Solver = Solver(self.SudokuGenerator.grid) self.selected_row = 4 self.selected_col = 4 self.pressed_key = None self.is_solving = False self.is_solved = False self.initial_time_check_num = 0 self.elapsed_time_check_box = 0 self.sudoku_start_time = time.time() self.elapsed_time = 60 # round(time.time() - self.sudoku_start_time, 2) self.elapsed_minutes = int(self.elapsed_time // 60) self.elapsed_seconds = self.elapsed_time - (self.elapsed_minutes * 60) self.submit_counter = 0
def __init__(self): self.__table = [[(j + i * 3 + (i // 3 + 1)) % Board.rows + 1 for j in range(Board.rows)] for i in range(Board.rows)] self.__begin_table = [[0 for j in range(Board.rows)] for i in range(Board.rows)] self.__solver = Solver()
def brute_force_trials(self, trials, timeout, test_cases, target_numbers, debug): solved = 0 off = 0 time_solved = 0 time_unsolved = 0 for i in range(trials): if i % (trials / 10) == 0: print("x", end='', flush=True) start = time.clock() nums = test_cases[i] if debug: print(nums) target = target_numbers[i] if debug: print("Target: " + str(target)) solver = Solver(self.n, target, nums, timeout, debug) (closest, solution) = solver.brute_force() elapsed = time.clock() - start if (closest == target): time_solved = time_solved + elapsed solved = solved + 1 else: time_unsolved = time_unsolved + elapsed off = off + abs(closest - target) if debug: print("Closest: " + str(closest) + "( " + str(abs(target - closest)) + " off)") print(solution) print("") # print("Percentage Solved: " + str(100 * solved / trials) + "%") # print("Average Error: " + str(off/trials)) # print("Total Time: " + str(time_solved + time_unsolved)) # if solved==0: # print("Average Time for Solved Case: " + str(0)) # else: # print("Average Time for Solved Case: " + str(time_solved/solved)) # if trials-solved==0: # print("Average Time for Unsolved Case: " + str(0)) # else: # print("Average Time for Unsolved Case: " + str(time_unsolved/(trials - solved))) #15, 8, 15, 12, 14, 11 ps = str("{0:.2f}".format(100 * solved / trials)) + "%" ae = str("{0:.2f}".format(off / trials)) tt = str("{0:.3f}".format(time_solved + time_unsolved)) + "s" if solved == 0: asc = str(0) + "s" else: asc = str("{0:.3f}".format(time_solved / solved)) + "s" if trials - solved == 0: auc = str(0) + "s" else: auc = str("{0:.3f}".format(time_unsolved / (trials - solved))) + "s" print("|Brute Force |" + ps + (8 - len(ps)) * " " + "|" + ae + (15 - len(ae)) * " " + "|" + tt + (12 - len(tt)) * " " + "|" + asc + (12 - len(asc)) * " " + "|" + auc)
def main(): vrp_set_path = './Vrp-Set-E' problem_path = os.path.join(vrp_set_path, 'E-n30-k3.vrp') solver = Solver(problem_path) cost, route = solver.binary_cws_mcs(n=50, distributed=True) print("cost: ", cost, "\n routes: ", route)
def test_newton(self): """ Test rosenbrock function """ s = Solver(self.problem) result = s.newton(mode='default') expected = array([1., 1.]) self.assertAlmostEqual(0, norm(result - expected))
def _configure(self): """ Set members based using inventory. """ Solver._configure(self) ModuleSolverNonlinear.skipNullSpaceCreation(self, not self.createNullSpace) return
def test_exact_line_search(self): """ Test Exact line search """ s = Solver(self.problem) result = s.newton(mode='exact', maxIteration=400) expected = array([1., 1.]) self.assertAlmostEqual(result[0], expected[0]) self.assertAlmostEqual(result[1], expected[1])
def initialize(self, application): Solver.initialize(self, application) self.coupler = application.coupler self.myPlus = application.myPlus self.remotePlus = application.remotePlus self.coupler.initialize(self) return
def _configure(self): """ Set members based using inventory. """ Solver._configure(self) ModuleSolverLinear.skipNullSpaceCreation(self, not self.createNullSpace) return
def main(): vrp_set_path = './Vrp-Set-E' problem_path = os.path.join(vrp_set_path, 'E-n13-k4.vrp') for generator in generators: solver = Solver(problem_path, generator) cost, route_list = solver.binary_cws() print("cost: ", cost) print("route: ", route_list) print("------------------------------")
def f1(): config = read_input('input.txt') solver = Solver() cost = solver.solve(config) print('[f1]: Least energy required = %d' % (cost)) return
def test_newton_converge_fail(self): self.setGuess(array([699, 30300])) s = Solver(self.problem) result = s.newton(mode='default', maxIteration=50) expected = array([1., 1.]) close = np.isclose( result, expected ) #Check that the result is 'Not almost equal' the expected value self.assertFalse(close[0]) self.assertFalse(close[1])
def run(self): while True: buffer = BytesIO(urlopen(captcha_url).read()) solver = Solver(Image.open(buffer), captcha_length) while len(solver.char_areas) != captcha_length: buffer = BytesIO(urlopen(captcha_url).read()) solver = Solver(Image.open(buffer), captcha_length) buffer.seek(0) captcha_result = solver.get_result() CaptchaGatherThread.captchas.put({"captcha": Image.open(buffer), "solver": solver, "guess": captcha_result})
def run(self): while True: solver = None while solver is None or len(solver.char_areas) != captcha_length: rep = urlopen(captcha_url) answer = rep.info()['x-captcha-code'] print(answer) buffer = BytesIO(rep.read()) solver = Solver(Image.open(buffer), captcha_length) buffer.seek(0) captcha_result = solver.get_result() CaptchaGatherThread.captchas.put({"captcha": Image.open(buffer), "solver": solver, "guess": captcha_result, "answer": answer}) print('Put')
def run(self): while True: buffer = BytesIO(self.opener.open(captcha_url).read()) try: solver = Solver(Image.open(buffer), captcha_length) except Exception as e: print("Rate limit exceeded: ", e) return while len(solver.char_areas) != captcha_length: buffer = BytesIO(self.opener.open(captcha_url).read()) solver = Solver(Image.open(buffer), captcha_length) buffer.seek(0) captcha_result = solver.get_result() CaptchaGatherThread.captchas.put({"captcha": Image.open(buffer), "solver": solver, "guess": captcha_result})
def __init__(self, test=None, full=True, L=True, OD=True, CP=True, LP=True, eq='CP', damp=0, noise=0.0): Solver.__init__(self) self.test = test self.eq = eq self.full = full self.L = L self.OD = OD self.CP = CP self.LP = LP self.damp = damp self.data, self.A, self.b, self.x0, self.x_true = None, None, None, \ None, None
class Algorithm: """ Interface from mainfile Input: node_set """ def __init__(self,node_set): self.node_set=node_set #Initialize all the variables Initialization.Initialization(self.node_set) self.solver=Solver(self.node_set) def getResult(self): primalRes,dualRes,exeTime=self.solver.start(ct.Constant().numIter) var=self.node_set obj=0 for n in var: obj+=sum(n.z_npower)[0,0].real return (primalRes,dualRes,exeTime,var,obj)
bc_filename=filename + ".bc", ) simu = Simulation() simu.read_solver_input(filename + ".msh") simu.domain.read_mesh_file(filename + ".msh", True) simu.domain.read_bc_file(simu.bc_filename) reg_filename = simu.bc_filename.split(".bc")[0] simu.domain.read_regions_file(reg_filename) inter = Interpreter() eq = inter.build_harmonic_EM_eq(simu) g = eq["sol_vec"] my_solver = Solver() value, fields = my_solver.solve_spectral(simu, eq) print len(fields), "value", sqrt(value) quads = my_solver.substract_1(simu.domain.elements.quads.el_set) quads = quads[:, 1:] for i in range(len(fields)): field3 = zeros((simu.domain.nodes.n, 3)) field3[:, 0:2] = fields[i] fields[i] = field3 # dir_sol = zeros(g.shape[0]) # remove = eq['dir_positions'] # g = my_solver.build_solution(dir_sol, g, remove, True) # field2 = zeros((simu.domain.nodes.n,3)) # field2[:,0:2] = g # g_sol = field2
def __init__(self, sparse=False, full=True, L=True, OD=True, CP=True, LP=True, noise=0.0): Solver.__init__(self, full=full, L=L, OD=OD, CP=CP, LP=LP, noise=noise) self.sparse = sparse
def _solve_sudoku(read_grid): solver = Solver(read_grid) if solver.solve(): return solver.sudoku_grid else: return None
#!/usr/bin/python3 from Solver import Solver from World import World if __name__ == "__main__": world = World(3, 3) solver = Solver(world) solution = solver.find_solution() if not solution == None: print("SOLUTION FOUND!\n") solution.print_history() else: print("NO SOLUTION FOUND.")
from write import write_vtk, write_solver_input import matplotlib.pyplot as plt from matplotlib import rc filename = 'unit_cell_1-02_two_reg' write_solver_input(filename +'.msh',dimension = 2, bc_type = 'Bloch', \ parameter = [], eq = 'EM', sol_type = 'Stationary',analysis_param \ = ['y', 'y', 15, 15, 21, 21, 5], bc_filename = filename +'_guide.bc') simu = Simulation() simu.read_solver_input(filename +'.msh') simu.domain.read_mesh_file(filename +'.msh',simu) inter = Interpreter(vectorial = True) eq = inter.build_EM_bloch_eq(simu) my_solver = Solver() k_coords, energy = my_solver.solve_bloch_Brillouin(simu, eq) fig = plt.figure() ax = fig.add_subplot(111) plt.title("Dispersion relations for Square lattice") k_div = k_coords.shape[0]/3 from numpy import sqrt, around print max(energy[:,-1]) for i in range(energy.shape[1]): energy[:,i] = sqrt(around(energy[:,i],10)) ax.plot(energy[:,i]) l = plt.axvline(x=k_div) l = plt.axvline(x=k_div*2+1) l = plt.axvline(x= k_coords.shape[0])
from Solver import Solver from Board import Board if __name__ == '__main__': ## No solucionables: #board = Board([[1,2,3],[4,5,6],[8,7,0]]) ## Se desfazan en numero de pasos: #board = Board([[7,2,4],[5,0,6],[8,3,1]]) #board = Board([[6,0,5],[8,7,4],[3,2,1]]) board = Board([[8,6,7],[2,5,4],[3,0,1]]) ## Solucionables de inmediato: #board = Board([[0,2,3],[1,4,6],[7,5,8]]) #4 #board = Board([[1,8,2],[0,4,3],[7,6,5]]) #10 #board = Board([[0,1,3],[4,2,5],[7,8,6]]) #5 solver = Solver(board) print 'board:\n' print board print '\nsolution\n' print solver.moves() ##Take care of: #print len(solver.close) #print len(solver.opened) #print board #for i in board.neighbors(): # print i
def stableTimestep(self): dt = self.inventory.timestep Solver.stableTimestep(self, dt) return dt
vals.append(-i) else: vals.append(i) return vals if __name__ == "__main__": if len(sys.argv) < 2: print("Usage: python3 main.py <file>") # sys.exit() # file_name = sys.argv[1] satisfiable = False # class Solver contain algorithms URW, WalkSAT, TabuSearch and their helper functions solver = Solver() # class CNF handles files, create datastructures for CNFs and provide function to check if formula is satisfied cnf = CNF() csp = CSP() if len(sys.argv) == 2: file_name = sys.argv[1] solver = Solver() cnf = CNF() cnf.read_dimacs_file(file_name) start = time.time() satisfiable = solver.URW(cnf, 100000) end = time.time()
def dotrain(): if len(sys.argv)>1: wps = open(sys.argv[1]).readlines() answs = open(sys.argv[2]).readlines() else: wps = open("emnlp_noIrrelev_p.txt").readlines() answs = open("emnlp_noIrrelev_a.txt").readlines() problematic = open('nogoodtrainproblems','w') bigtexamples = {x:([],[]) for x in ["+","*",'/','-','=']} replacements = {' two ':' 2 '," three ":' 3 ',' four ':' 4 ',' five ':' 5 ',' six ':' 6 ',' seven ':' 7 ',' eight ':' 8 ',' nine ':' 9 ',' ten ':' 10 ',' eleven ':' 11 ',' week ':' 7 days ',' dozen ':' 12 of ', ' dozens ': ' 12 ', ' twice ':' 2 '} for k in range(len(wps)): print(k) problem = wps[k].lower() for r in replacements: problem = problem.replace(r,replacements[r]) #extract numbers: #problem = ' '.join([x.replace(",","") for x in problem.split()]) story = nlp.parse(problem) numbs = makesets.makesets(story['sentences']) numlist = [(cleannum(v.num),v) for k,v in numbs] numlist = [x for x in numlist if x[0]!=''] allnumbs = {str(k):v for k,v in numlist} if 'x' not in allnumbs: if 'x*' not in allnumbs: problematic.write('no x :'+problem); continue objs = {k:(0,v) for k,v in numlist} print('start solving') print(numlist) if len(numlist)<2: problematic.write("not enough numbers : "+problem);continue ST = Solver([x[0] for x in numlist if x[0]!='x']) answers = ST.solveEquations(float(answs[k])) print('done solving') #filter out where = in middle if simpler eq exists simpleranswers = [x for x in answers if x.split(" ")[1] == '=' or x.split(" ")[-2]=="="] if not answers: continue if simpleranswers: answers = simpleranswers else: print(answers) problematic.write("not simple : "+problem);continue answervals = [x for x in answers[0].split(" ") if x not in ['+','-','/','=',')','(','*']] numvals = [x[0] for x in numlist if x[0] in answervals] xidx = numvals.index("x") rightidx = [i for i,x in enumerate(answers) if [z for z in x.split(" ") if z not in ['+','-','/','=',')','(','*']].index('x')==xidx] xrightanswers = [answers[i] for i in rightidx] if xrightanswers: answers = xrightanswers for j,eq in enumerate(answers): trips = [] print(j,eq) l,r = [x.strip().split(' ') for x in eq.split('=')] compound = l if len(r)==1 else r simplex = l if len(l)==1 else r target = simplex[0] target = (target,objs[target]) #find innermost parens? while len(compound)>1: if "(" in compound: rpidx = (len(compound) - 1) - compound[::-1].index('(') lpidx = rpidx+compound[rpidx:].index(")") subeq = compound[rpidx+1:lpidx] substr = "("+''.join(subeq)+")" compound = compound[:rpidx]+[substr]+compound[lpidx+1:] else: subeq = compound[0:3] substr = "("+''.join(subeq)+")" compound = [substr]+compound[3:] if True: p,op,e = subeq #print(p,op,e) p = objs[p] e = objs[e] op = op.strip() trips.append((op,p,e)) pute = (0,makesets.combine(p[1],e[1],op)) #print("OPERATION SELECTED: ",op) #p.details() #e.details() #print(substr,pute[1].num) objs[substr]=pute if pute == -1: exit() if simplex == l: trips.append(("=",objs[simplex[0]],objs[compound[0]])) else: trips.append(("=",objs[compound[0]],objs[simplex[0]])) t = training(trips,problem,target) for op in t: bigtexamples[op][0].extend(t[op][0]) bigtexamples[op][1].extend(t[op][1]) print(op,len(bigtexamples[op][0])) pickle.dump(bigtexamples,open('data/dev_training.pickle','wb'))
def _configure(self): """ Set members based using inventory. """ Solver._configure(self) return
"cnf_exercise5/random_ksat(3).dimacs", "cnf_exercise5/random_ksat(4).dimacs", "cnf_exercise5/random_ksat(5).dimacs", "cnf_exercise5/random_ksat(6).dimacs", "cnf_exercise5/random_ksat(7).dimacs", "cnf_exercise5/random_ksat(8).dimacs", "cnf_exercise5/random_ksat(9).dimacs", "cnf_exercise5/random_ksat(10).dimacs", "cnf_exercise5/random_ksat(11).dimacs", "cnf_exercise5/random_ksat(12).dimacs", # "cnf_exercise5/random_ksat(13).dimacs", # "cnf_exercise5/random_ksat(14).dimacs", ] # dataSets = ["cnf_exercise5/random_ksat(6).dimacs"] # class Solver contain algorithms URW, WalkSAT, TabuSearch and their helper functions solver = Solver() # class CNF handles files, create datastructures for CNFs and provide function to check if formula is satisfied cnf = CNF() num_runs = 20 time_matrix1= np.zeros((len(dataSets), num_runs)) time_matrix2= np.zeros((len(dataSets), num_runs)) for j, dataSet in enumerate(dataSets): print("\nFor dataset:", dataSet) for run in range(num_runs): print("\nRun#:",run, "For dataset:",dataSet) file_name = dataSet solver = Solver() cnf = CNF()
parameter = [], eq = 'EM', sol_type = 'Stationary',analysis_param \ = ['y', 'y', 4, 4, 20, 20, 2], bc_filename = filename+'.bc') simu = Simulation() simu.read_solver_input(filename +'.msh') simu.domain.read_mesh_file(filename +'.msh', True) simu.domain.read_bc_file(simu.bc_filename) reg_filename = simu.bc_filename.split('.bc')[0] simu.domain.read_regions_file(reg_filename) inter = Interpreter() eq = inter.build_static_EM_eq(simu) g = eq['sol_vec'] my_solver = Solver() fields = my_solver.solve_stationary(simu, eq) quads = my_solver.substract_1(simu.domain.elements.quads.el_set) quads = quads[:,1:] field3 = zeros((simu.domain.nodes.n,3)) field3[:,0:2] = fields fields = field3 dir_sol = zeros(g.shape[0]) remove = eq['dir_positions'] g = my_solver.build_solution(dir_sol, g, remove, True) print g field2 = zeros((simu.domain.nodes.n,3)) field2[:,0:2] = g g_sol = field2
from Interpreter import Interpreter from Solver import Solver from write import write_vtk, write_solver_input filename = 'unit_cell_1-02_two_reg' write_solver_input(filename +'.msh',dimension = 2, bc_type = 'Bloch', \ parameter = [], eq = 'EM', sol_type = 'Stationary',analysis_param \ = ['y', 'y', 15, 15, 11, 11, 5], bc_filename = filename +'.bc') simu = Simulation() simu.read_solver_input(filename +'.msh') simu.domain.read_mesh_file(filename +'.msh',simu) inter = Interpreter(vectorial = True) eq = inter.build_EM_bloch_eq(simu) my_solver = Solver() k_mesh, energy = my_solver.solve_bloch(simu, eq) from numpy import zeros, sqrt, around nodes = zeros((k_mesh[0].shape[0],3)) nodes[:,0:2] = k_mesh[0] triangles = k_mesh[1] for i in range(energy.shape[1]): energy[:,i] = sqrt(around(energy[:,i],10)) write_vtk('Bloch_periodic_r-a_1-02_two_reg'+str(i)+'.vtk','this shit','POLYDATA', nodes,\ triangles, ['SCALARS', ['sol'], [energy[:,i]]]) # from inform import inform
inter = Interpreter(vectorial =True) mass = inter.lumped_mass_matrix(simu) mass = mass[:,0] print sum(mass) for node in range(node_coords.shape[0]): dofs_past.append(DOF(node, simu, comp = 0, t = 0 * dt)) dofs_past.append(DOF(node, simu, comp = 1, t = 0 * dt)) dofs_present.append(DOF(node, simu, comp = 0, t = 1 * dt)) dofs_present.append(DOF(node, simu, comp = 1, t = 1 * dt)) dofs_future.append(DOF(node, simu, comp = 0, t = 2 * dt)) dofs_future.append(DOF(node, simu, comp = 1, t = 2 * dt)) snapshot = [dofs_past, dofs_present, dofs_future] from numpy import zeros, append, array solver = Solver() quads = solver.substract_1(simu.domain.elements.quads.el_set) quads = quads[:,1:] field3 = zeros((simu.domain.nodes.n,3)) for n in times: print n field = array([]) # for dof in snapshot[1]: # print 'dof.node_id',dof.node_id, 'value', dof.value for dof in range(len(snapshot[0])): E_past = snapshot[0][dof] E_present = snapshot[1][dof] E_future = snapshot[2][dof] if E_future.check_if_in_boundary(simu, t = n*dt) == False: Fi = E_present.find_surrounding_elements(snapshot[1], simu) F = -Fi + 1.0/(dt**2)*mass[dof]*(2*E_present.value - E_past.value)
def __init__(self, name=None): if name is None: name = "simpleSolver" Solver.__init__(self, name) return