def test_lu_for_ints(self): rand_int_matrix = np.random.randint(-1000, 1000, size=(1000, 1000)) rand_int_col = np.random.randint(-1000, 1000, size=(1000, 1)) sp_solve2 = sp.solve(rand_int_matrix, rand_int_col) assert_array_almost_equal(sp_solve2, solve.solve(rand_int_matrix, rand_int_col, 1), decimal=9) assert_array_almost_equal(sp_solve2, solve.solve(rand_int_matrix, rand_int_col, 2), decimal=9) assert_array_almost_equal(sp_solve2, solve.solve(rand_int_matrix, rand_int_col, 3), decimal=9)
def anneal(h, J, g0, steps=50): '''Get ground state configuration of a circuit specified by h and J for gammas values from g_max to g_min''' time = np.linspace(0, 1, steps) spectrum = [] ground = [] excited = [] for i in xrange(0, steps): fact = (i+1)*1./(steps+1) gamma = g0*(1-fact) if DUAL: _h, _J = fact*h, fact*J else: _h, _J = h, J gs, es, spec, sols = solve(_h, _J, gamma=gamma, full_output=True, minimal=False, exact=False) spectrum.append(np.array(spec[0::])) ground.append(np.abs(np.array(sols['eigsh']['vecs'][:, 0]))) excited.append(np.abs(np.array(sols['eigsh']['vecs'][:, 1]))) spectrum = np.array(spectrum) ground = np.array(ground) excited = np.array(excited) # identify ground state components # echo_comp(ground[int(.8*steps)]) # echo_comp(excited[int(.8*steps)]) # echo_comp(excited[int(.9*steps)]) plt.figure('Spectrum') plt.clf() plt.plot(time, spectrum, linewidth=2) plt.xlabel('Time', fontsize=FS) plt.ylabel('Energy', fontsize=FS) plt.title('Low Energy Spectrum', fontsize=FS) plt.show(block=False) if SAVE: plt.savefig(ROOT+'spec.eps', bbox_inches='tight') plt.figure('Ground State Configuration') plt.clf() plt.plot(time, np.power(ground, 2), linewidth=2) plt.xlabel('Time', fontsize=FS) plt.ylabel('Basis state probabilities', fontsize=FS) plt.title('Ground state configuration', fontsize=FS) plt.show() if SAVE: plt.savefig(ROOT+'gr.eps', bbox_inches='tight') if True: plt.figure('Excited State Configuration') plt.clf() plt.plot(time, np.power(excited, 2), linewidth=2) plt.xlabel('Time', fontsize=FS) plt.ylabel('Basis state probabilities', fontsize=FS) plt.title('Excited State Configuration', fontsize=FS) plt.show() if SAVE: plt.savefig(ROOT+'ex.eps', bbox_inches='tight')
def b4click(event): global li1 global li2 f = open("puzzle.txt", "wb") #check for validity categories = categoriesList() topinfo = topInfo(categories) if topinfo == None: return #start building the list of items ls = [topinfo] #add all the category information for c in categories: ls.extend(c) #add all the relation information ls.extend(list(li2.get(0, END))) #save the file for l in ls: f.write(bytes(l + "\n", "UTF-8")) print("Saving to puzzle.txt") f.close() #solve the puzzle and print it print("Solving the puzzle") answer = sortedAnswer(list(solve(parse_file("puzzle.txt")))) #show the answer in a window response = Tk() #make a grid with each row being the entity for row in answer: r = Frame(response) r.pack() #each item belonging to the entity for item in row: l = Label(r, text=item + "\t", width=12) l.pack(side=LEFT) response.mainloop()
def main(): for index, test in enumerate(get_tests()): array, target_sum = test print( "Test %d\nFor array %s\nSum %d\nPair found: %s\n\n" % (index, array.__repr__(), target_sum, solve(array, target_sum).__repr__()) )
def main(): args = docopt.docopt(__doc__) data = read_data(args['<in>']) score, result = solve(data) print(score) score2, result2 = optimize(result, data) print(score2) format_solution(args['<out>'], result2, prefix=str(score))
def main(): board = [None for _ in range(64)] regs = {} read_regions(sys.stdin, regs) read_board(sys.stdin, regs) lregs = invert_regions(build_regions(regs)) #list(map(print, enumerate(lregs))) for sol in solve(board, lregs): print_board(sol)
def main(lines): # for i, v in enumerate(lines): # print("line[{0}]: {1}".format(i, v)) H, W = map(int, lines[0].split()) S = [list(l) for l in lines[1:-1]] T = lines[-1] ans = solve(H, W, S, T) print(ans)
def test_solve(): arr = ['Begin on 3rd Blvd', 'Right on First Road', 'Left on 9th Dr'] rev = ['Begin on 9th Dr', 'Right on First Road', 'Left on 3rd Blvd'] assert solve(arr) == rev arr = [ "Begin on Road A", "Right on Road B", "Right on Road C", "Left on Road D" ] rev = [ 'Begin on Road D', 'Right on Road C', 'Left on Road B', 'Left on Road A' ] assert solve(arr) == rev arr = ["Begin on Road A"] rev = ["Begin on Road A"] assert solve(arr) == rev
def test_solve(): assert solve("aaab") is False assert solve("abcabc") is False assert solve("4455") is True assert solve("zazcbaabc") is True assert solve("223456776543") is True assert solve("432612345665") is False assert solve("qponmlkjihgfeeiefghijklmnopqrsttsr") is False
def test_solve(): assert solve("codewarriors") == 2 assert solve("suoidea") == 3 assert solve("ultrarevolutionariees") == 3 assert solve("strengthlessnesses") == 1 assert solve("cuboideonavicuare") == 2 assert solve("chrononhotonthuooaos") == 5 assert solve("iiihoovaeaaaoougjyaw") == 8
def test_my_answer(self): for i in range(233): length = random.randint(1, 10**3) a_list = str() for j in range(length): a_list += "{} ".format(random.randint(0, 10**4)) right_answer = "{} {}".format(*right(length, a_list)) my_answer = solve(length, a_list) self.assertEqual(right_answer, my_answer)
def rfileext(): pygame.quit() inputFile = input("Masukkan nama file input! ") outputFile = input("Masukkan nama file output! ") orig_stdout = sys.stdout orig_stdin = sys.stdin fin = open(inputFile, 'r') fout = open(outputFile, 'w') sys.stdin = fin sys.stdout = fout a, b, c, d = map(int, input().split()) card = [a, b, c, d] solve(card) sys.stdout = orig_stdout sys.stdin = orig_stdin print("file telah di save di ", outputFile) fin.close() fout.close() quit()
def main(): #fetching the sudoku path = os.path.abspath("sudoku.json") with open(path) as data_: data = json.load(data_) sudoku = data['sudoku'] # validate the sudoku validation = (validate.run(sudoku)).Validate() if validation is False: print("Sudoku is invalid.") else: print("Sudoku valid. Solved:") solve.solve(sudoku) for list_ in sudoku: print(list_) return
def main(): random.seed(int(sys.argv[-1])) n = int(cmdlinearg("n")) m = int(cmdlinearg("m")) onlyForward = cmdlinearg("onlyForward")=="True" g = random.randint(1,1e2) MAX_SPEED = 1e2 band = [] for i in range(n): a=0 b=0 while True: a = random.randint(0,m-1) b = random.randint(0,m-1) if a!=b: break band.append([min(a,b),max(a,b),random.randint(1,MAX_SPEED)]) if onlyForward: dn = 1 up = len(band) while dn+1<up:#binärsök efter minsta antalet band att ta bort så att det räcker att bara gå framåt mid = (dn+up)//2 if solve(n,m,g,band[:mid],onlyForward=True)==solve(n,m,g,band[:mid]): dn = mid else: up = mid band = band[:dn] #assert(solve(n,m,g,band,onlyForward=True)==solve(n,m,g,band)) #assert(solve(n,m,g,band,onlyForward=True)==solve(n,m,g,band)) random.shuffle(band) print(len(band),m,g) for b in band: print(b[0]+1,b[1]+1,b[2])
def main(): test_index = 1 for array, rotations, element in get_tests(): array = list(set(array)) array.sort() array = rotate(array, rotations) print("Test %d: Array: %s\nSearching for %d\nFound at index %d\n\n" % (test_index, array.__repr__(), element, solve(array, element))) test_index += 1
def makeSamples(size): fixed_sample_0 = torch.zeros(1, 1, size, size) setBoundaries(fixed_sample_0, 100, 100, 0, 0) fixed_sample_0 = Variable(fixed_sample_0).cuda() fixed_sample_1 = torch.zeros(1, 1, size, size) setBoundaries(fixed_sample_1, 100, 100, 100, 100) fixed_sample_1 = Variable(fixed_sample_1).cuda() boundary = np.zeros((1, 1, size, size), dtype=np.bool) setBoundaries(boundary, 1, 1, 1, 1) fixed_solution_0 = solve(fixed_sample_0.cpu().data.numpy()[0, 0, :, :], np.squeeze(boundary), tol=1e-5) fixed_solution_1 = solve(fixed_sample_1.cpu().data.numpy()[0, 0, :, :], np.squeeze(boundary), tol=1e-5) return fixed_sample_0, fixed_solution_0, fixed_sample_1, fixed_solution_1
def main(): parser = argparse.ArgumentParser(description='Nonogram runner') parser.add_argument('constraints_file', type=str, help='.npy file containing constraints') args = parser.parse_args() nono = Nonogram(args.constraints_file) solution = solve(nono.constraints) if nono.isValidSolution(solution): print('\x1b[6;30;42m' + 'Success!' + '\x1b[0m') else: print('\x1b[3;30;41m' + 'Failure.' + '\x1b[0m')
def test_solve(self): test_data = "220422197205148440" right_answer = False my_answer = solve(test_data) self.assertEqual(right_answer, my_answer) test_data = "654201199306252458" right_answer = True my_answer = solve(test_data) self.assertEqual(right_answer, my_answer) test_data = "440407198504173971" right_answer = True my_answer = solve(test_data) self.assertEqual(right_answer, my_answer) test_data = "51312419920924287X" right_answer = True my_answer = solve(test_data) self.assertEqual(right_answer, my_answer)
def average_100(number): moves_no = [] sln_moves = [] demo_cube = cube.Cube() for i in range(100): demo_cube.scramble(int(number)) sln_moves = solve.solve(demo_cube) moves_no.append(len(sln_moves)) total = sum(moves_no) print("average number of moves used over 100 runs is: {}".format(total / 100))
def run(self): """ Call this method to run the model with current SAS specification, options, solute parameters, and timeseries dataframe. Results can then be accessed through the `.result` property of the model object :return: None """ # water fluxes J = self.data_df[self.options['influx']].values Q = self.data_df[self._fluxorder].values sT_init = self.options['sT_init'] timeseries_length = self._timeseries_length numflux = self._numflux # # SAS lookup table SAS_args, P_list, weights, component_type, nC_list, nC_total, nargs_list, nargs_total = self._create_sas_lookup() SAS_args = np.asfortranarray(SAS_args) P_list = np.asfortranarray(P_list) weights = np.asfortranarray(weights) # # Solutes C_J, mT_init, C_old, alpha, k1, C_eq = self._create_solute_inputs() numsol = self._numsol # # options dt = self.options['dt'] verbose = self.options['verbose'] debug = self.options['debug'] warning = self.options['warning'] jacobian = self.options['jacobian'] n_substeps = self.options['n_substeps'] max_age = self.options['max_age'] # call the Fortran code fresult = solve( J, Q, SAS_args, P_list, weights, sT_init, dt, verbose, debug, warning, jacobian, mT_init, np.asfortranarray(C_J), np.asfortranarray(alpha), np.asfortranarray(k1), np.asfortranarray(C_eq), C_old, n_substeps, component_type, nC_list, nargs_list, numflux, numsol, max_age, timeseries_length, nC_total, nargs_total) sT, pQ, WaterBalance, mT, mQ, mR, C_Q, dsTdSj, dmTdSj, dCdSj, SoluteBalance = fresult if numsol > 0: self._result = {'C_Q': C_Q} for isol, sol in enumerate(self._solorder): for iflux, flux in enumerate(self._fluxorder): colname = sol + ' --> ' + flux self._data_df[colname] = C_Q[:, iflux, isol] else: self._result = {} self._result.update({'sT': np.moveaxis(sT, -1, 0), 'pQ': np.moveaxis(pQ, -1, 0), 'WaterBalance': np.moveaxis(WaterBalance, -1, 0), 'dsTdSj':np.moveaxis(dsTdSj, -1, 0)}) if numsol > 0: self._result.update({'mT': np.moveaxis(mT, -1, 0), 'mQ': np.moveaxis(mQ, -1, 0), 'mR': np.moveaxis(mR, -1, 0), 'SoluteBalance': np.moveaxis(SoluteBalance, -1, 0), 'dmTdSj':np.moveaxis(dmTdSj, -1, 0), 'dCdSj':dCdSj})
def solve(board, regs, pos=0): #print_board(board) if pos == 64: yield board else: for i in range(1, 9): #print(i) board[pos] = i if all(r.isvalid(board) for r in regs[pos]): yield from solve(board, regs, pos + 1) board[pos] = None
def test_unsolvables(): test_paths = glob.glob( os.path.join(os.path.dirname(__file__), 'unsolvable/test??')) for test_path in test_paths: with open(test_path) as f: test = parse_state(f) check = lambda: nose.tools.assert_equals(solve(test), None) check.description = 'unsolvable/' + test_path.split('/')[-1] yield check
def main(file): """ The file handler. Reads all input files and passes the string to the solver. Write the solvers output string to the appropriate file. """ with open(file[0], 'r') as inp, open(file[1], 'w') as out: # Call appropriate solver out_str = solve.solve(inp) # Copy string data to solver data = inp.read() # Create output file out.write(out_str) print(f'DONE: {file[0]}, SCORE: {score.score(data, out_str)}')
def main(): if (len(sys.argv) != 4): error.error('python main.py [file] -h [0|1|2]') if (not isInt(sys.argv[3])): error.error('python main.py [file] -h [0|1|2]') sys.argv[3] = int(sys.argv[3]) if (sys.argv[2] != '-h' or sys.argv[3] < 0 or sys.argv[3] > 2): error.error('python main.py [file] -h [0|1|2]') filename = sys.argv[1] content = '' try: f = open(filename, 'r') content = f.read() f.close() except: error.error('error opening file') content = cleanContent(content) puzzle = checkContent(content) goal = getGoalState(len(puzzle)) checkSolvable(puzzle, goal) solve.solve(puzzle, goal)
def predict(): content = request.get_json() target_cube = turn(content) if type(target_cube) == "str": return json.dumps([False, "Invalid input"]) if target_cube.is_valid() == False: return json.dumps([False, "Invalid input"]) is_solved, actions = solve(target_cube) results = [is_solved, actions] return json.dumps(results)
def main(): while True: image = ImageGrab.grab(bbox = (left, upper, right, lower)) tesstr = pytesseract.image_to_string( cv2.cvtColor(nm.array(image), cv2.COLOR_BGR2GRAY), lang ='eng') if "Quick!" in tesstr: print(tesstr) prompt = "".join(char for char in detect_prompt(tesstr).lower() if char.isalpha()) print(prompt) solution = solve.solve(prompt) time.sleep(delay) enter_solution(solution)
def do(data,stage): st = time.perf_counter() im = base64.decodebytes(data.encode()) try: os.makedirs(base+("/temp/%d"%stage)) except: pass name = base+"/temp/%d/%s.bmp" %(stage,''.join(random.choices(string.ascii_lowercase,k=10))) with open(name, "wb") as f: f.write(im) sol = solve.solve(name) #print((time.perf_counter()-st)) return sol
def place(self, val): row, col = self.selected if self.cubes[row][col].value == 0: self.cubes[row][col].set(val) self.update_model() if valid(self.model, val, (row,col)) and solve(self.model): return True else: self.cubes[row][col].set(0) self.cubes[row][col].set_temp(0) self.update_model() return False
def runTest(net): files = glob(opt.experiment + "/*.pth") maximum = 0 for file in files: maximum = max(int(file.split("_")[-1].split(".")[0]), maximum) file = glob(opt.experiment + "/*" + str(maximum) + ".pth")[0] print(file) state_dict = torch.load(file) # state_dict = torch.load(file, map_location=lambda storage, loc: storage.cuda(1)) net.load_state_dict(state_dict) physical_loss = PhysicalLoss() boundary = np.zeros((opt.image_size, opt.image_size), dtype=np.bool) boundary[0, :] = True boundary[-1, :] = True boundary[:, 0] = True boundary[:, -1] = True data = torch.zeros(1, 1, opt.image_size, opt.image_size) error = [] for i in range(opt.num_test): data[:, :, :, 0] = np.random.uniform(100) data[:, :, 0, :] = np.random.uniform(100) data[:, :, :, -1] = np.random.uniform(100) data[:, :, -1, :] = np.random.uniform(100) solution = solve(data.cpu().numpy()[0, 0, :, :], boundary, tol=1e-5) img = Variable(data).type(dtype) output = net(img) loss = physical_loss(output) output = output.cpu().data.numpy()[0, 0, :, :] error.append(np.mean(np.abs(output - solution))) print("%d Error: %.2f, Loss: %.2f" % (i, error[-1], loss.data[0])) # Plot imgs_comb = np.hstack( (boundaryPlot(data.cpu().numpy()[0, 0, :, :]), solution, output)) plt.imsave(fname='%s/test_%d.png' % (opt.experiment, i), arr=imgs_comb, vmin=0, vmax=100, cmap=plt.cm.jet) error = np.array(error) print("error: ", np.mean(error)) print("std dev: ", np.std(error))
def shpol(problem): if "from" in problem and "to" in problem: indexoffrom = problem.find("from") indexofto = problem.find("to") polname = problem[5:indexoffrom].strip() a = solve.solve(problem[indexoffrom + 4:indexofto]) if a.isError: return a if not a.isConstant(): a.isError = True a.errorCode = 9 return a b = solve.solve(problem[indexofto + 2:]) if b.isError: return b if not b.isConstant(): b.isError = True b.errorCode = 9 return b for canvas in CanvasArray: if canvas.name == polname: canvas.show(a.coefArr[0], b.coefArr[0]) return False ret = polynomial.polynomial() ret.isError = True ret.errorCode = 6 ret.errorStatement = polname return ret polname = problem[5:].strip() for canvas in CanvasArray: if canvas.name == polname: canvas.show() return False ret = polynomial.polynomial() ret.isError = True ret.errorCode = 6 ret.errorStatement = polname return ret
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--method", nargs='?', const=factory.DefaultMethod, default=factory.DefaultMethod, choices=factory.MethodChoices) parser.add_argument("--priority-queue", nargs='?', const=None, default=None, choices=factory.PriorityQueueChoices, help="only used by the astar and dijkstra methods") parser.add_argument("width") parser.add_argument("height") parser.add_argument("maze_file") parser.add_argument("result_file") parser.add_argument("generate_bmp", nargs='?', default='no') args = parser.parse_args() generate_bmp_bool = str2bool(args.generate_bmp) width = 0 height = 0 try: width = int(args.width) except: raise argparse.ArgumentTypeError('Width must be an integer.') try: height = int(args.height) except: raise argparse.ArgumentTypeError('Height must be an integer.') #print(width, height, args.output_file, generate_bmp_bool) generatemaze(width, height, args.maze_file, generate_bmp_bool) solve(args.maze_file + '.png', args.result_file + '.png', args.method, args.priority_queue)
def run(a, ansarea): #global ansarea commands = a.split("\n") ret = "\nrun started" for command in commands: if command == "" or command == " " or command.strip().replace( "\n", "") == "": continue #print("command:" + command + "ans : " + str(solve.solve(command))) a = solve.solve(command) if type(a) != type(False): if str(a).strip() != "": ret += '\n' + str(a) #ret+="\nrun ended" ansarea.insert(END, ret)
def execute(self, board, pents): self.initialize(board, pents) pygame.init() self.displaySurface = pygame.display.set_mode( (self.windowWidth, self.windowHeight), pygame.HWSURFACE) self.displaySurface.fill((255, 255, 255)) self.draw_board() pygame.display.flip() pygame.display.set_caption(self.windowTitle) sol_list = solve(board, pents, self) self.draw_solution_and_sleep(sol_list, 0) pygame.display.flip() if check_correctness(sol_list, board, pents): print("PASSED!") else: print("FAILED...") clock = pygame.time.Clock() clock = pygame.time.Clock() while self.running: pygame.event.pump() keys = pygame.key.get_pressed() clock.tick(self.fps) if (keys[K_ESCAPE]): raise SystemExit for event in pygame.event.get(): if event.type == pygame.QUIT: raise SystemExit while self.running: pygame.event.pump() keys = pygame.key.get_pressed() clock.tick(self.fps) if (keys[K_ESCAPE]): raise SystemExit for event in pygame.event.get(): if event.type == pygame.QUIT: raise SystemExit
def test(num_students, num_seminars): data = Data.factory(num_students, num_seminars) solution = solve.solve(data)[0] # Verify the class sizes print "Class sizes: " seminar_ctr = Counter() for decision in solution: seminar_ctr[decision[1]] += 1 sorted_sems = sorted(seminar_ctr.items()) for name, count in sorted_sems: print '%s: %d' % (name, count) print "\nAdded seminars (class: popularity):" num_extra = num_students % num_seminars popular_seminars = sorted(data.popular_seminars[0:num_extra]) for idx, count in popular_seminars: print '%s: %d' % (data.year_list[idx], count)
def profile(): for m in methods: for i in inputs: with tempfile.NamedTemporaryFile(suffix='.png') as tmp: solve(SolverFactory(), m, "examples/%s.png" % i, tmp.name)
def sweep_gamma(h, J, gmin, gmax, steps=2, show=True): '''Sweep gamma values for circuit (h, J) from gmin to gmax in the given number of steps.''' gammas = np.linspace(gmin, gmax, steps) egaps = [] Es = [] exact = len(h) < 8 for i in xrange(len(gammas)): gamma = gammas[i] sys.stdout.write('\r{0:.1f} %'.format(100*i/len(gammas))) sys.stdout.flush() gs, es, spec = solve(h, J, gamma=gamma, more=True, minimal=False, exact=exact) egaps.append([spec[i]-spec[0] for i in xrange(1, len(spec))]) Es.append(spec) egaps = np.array(egaps) Es = np.array(Es) Y = egaps if SHOW_GAPS else Es # correct for crossings Y = correct_crossings(Y) if show: plt.figure('Gamma sweep: egaps') if SHOW_GAPS: plt.plot(gammas, Y, 'x', markersize=MS, markeredgewidth=MEW) plt.xlabel('$\gamma$', fontsize=GFS) plt.ylabel('$E_{gap}$/$J$', fontsize=GFS) plt.ylim([0, plt.ylim()[1]]) else: plt.plot(gammas, Y, 'x', markersize=MS, markeredgewidth=MEW) plt.xlabel('$\gamma$', fontsize=GFS) plt.ylabel('$E$/$J$', fontsize=GFS) plt.tick_params(axis='both', which='major', labelsize=16) plt.show(block=False) # fitting # for i in range(Y.shape[1]): # try: # popt, func = hyper_fit(gammas, Y[:, i]) # plt.plot(gammas, func(gammas), '--') # except: # print('Fit failed...') # analytical solutions if True: E_an, eps_k = check_fermion_model(Y, h) plt.plot(gammas, E_an, 'k-', linewidth=2) else: if SHOW_GAPS: ground = np.zeros(gammas.shape, dtype=float) else: ground = analytical_ground(len(h), gammas) for n in xrange(0, N+1): gaps = analytical_gaps(len(h), n, gammas) for gap in gaps: plt.plot(gammas, ground+gap, 'k-', linewidth=2) # save figure if SAVE: plt.savefig('../img/wire_sol_{0}.eps'.format(len(h)), bbox_inches='tight') # force show with block if show: plt.show(block=True)
damping = grid.zeros() #wp.cosh_damping( grid, x1=grid.a1, x2=grid.b1, y1=grid.a2, y2=grid.b2, xs=50.0, ys=50.0, amp=1.0E4 ) k1 = 0.01*2.0*pi k2 = 0.01*2.0*pi u0 = lambda x1,x2: cos(x1*k1+x2*k2) #*(1.0+(1.15*(x1-1500.0)/2000.0)**48)**-1 *(1.0+(1.4*(x2-450)/750.0)**48)**-1 time_step=0.001 u0 = grid.evaluate( u0 ) u0 = u0 * exp( -damping * time_step ) results = solve(grid, initial_wave=u0, time_step=time_step, final_time= 1.0, damping=damping, velocity=velocity ) for step in range(len(results['files'])): data = scipy.io.loadmat( results['files'][step] ) u1 = data['m'].copy('C') #data = scipy.io.loadmat( results2['files'][step] ) #u2 = data['m'].copy('C') k=sqrt(k1*k1+k2*k2) t = float(step)*time_step u2 = grid.evaluate( lambda x1,x2: cos(x1*k1+x2*k2)*cos(c*t*k) ) render( u1-u2, "/workspace/output/acoustic_propagation/" + "%05d.png"%step , major_scale=1E-1, center=0.0 ) print step, norm( u1-u2 )/norm(u2)
def foo(pid): p = sil.Problem.read_by_pid(pid) print_info_about(p) ps = solve.solve(p) display_ps(ps)
# read board # if we were supplied a file, read it if board: print("Reading from file '{}'...".format(board.name)) board = read.read_file(board) # else we have to get it from the user else: print("Enter the known numbers (leaving spaces for those you don't know)...") now = time.clock() board = read.read_stdin() duration -= time.clock() - now # solve board if not no_solve: print("Solving... ", end='') board = solve.solve(board) # check if we're done if solve.done(board): done = True print("Solved!") # else resort to guessing else: now = time.clock() while True: response = input("\nBoard couldn't be solved by logic alone. Start guessing? [y/n] ") \ .strip().lower()[0] if response == 'y': print("Guessing... ", end='') start = time.clock()
mem = Member(mem_name) cat.add(mem) helper[mem_name] = mem puzzle.categories.append(cat) # use reflection to read the rest of the lines as clues! # TODO fix it so it doesn't crash if there are empty lines at the end of the file for line in f.readlines(): tokens = line.split() # special rules for Or. Hacky. if len(tokens) == 7 and tokens[3] == "Or": m1 = helper[tokens[0]] m2 = helper[tokens[2]] fun_string1 = tokens[1] + "(m1, m2)" m3 = helper[tokens[4]] m4 = helper[tokens[6]] fun_string2 = tokens[5] + "(m3, m4)" fun_string = "Or("+fun_string1+","+fun_string2+")" else: m1=helper[tokens[0]] m2 = helper[tokens[2]] fun_string = tokens[1] + "(m1, m2)" puzzle.relationships.append(eval(fun_string)) # return the puzzle object return puzzle if __name__ == "__main__": # if called from the command line also solve the puzzle # intended for informed debugging only; may break in startling ways solve(parse_file(sys.argv[1]))
if __name__ == '__main__': choice = easygui.ccbox(msg='Start solving puzzle?\nChoose a puzzle first.', title='Puzzle Solver v1.0', choices=('Continue', 'Cancel'), image=None) if choice: inputpath = easygui.fileopenbox(title='Choose a puzzle', default=None, filetypes=['*.txt']) puzzlename = inputpath.split('/')[-1].split('.')[0] outputpath = os.getcwd() + '/results/' + puzzlename msg = "Enable flipping and rotation?" title = 'Puzzle Solver v1.0' fieldName = ["Flipping", "Rotation"] fieldValue = [] fieldValue = easygui.multenterbox(msg, title, fieldName) FLIP = fieldValue[0] ROTATE = fieldValue[1] start = time.time() solve.solve(inputpath, FLIP, ROTATE) end = time.time() printstr = 'Total time: ' + str(end - start) + ' seconds' msg = "Solutions generated. Please choose one." fieldName = ["Solution number"] fieldValue = [] fieldValue = easygui.multenterbox(msg, title, fieldName) imgpath = outputpath + '/' + str(fieldValue[0]) + '.png' if os.path.exists(outputpath) and os.listdir(outputpath): easygui.msgbox(printstr, title, image=imgpath) else: easygui.msgbox("nothing found")
def run(): data = Data() with Timer('preparation'): #create element_table #data.tables.element_table = preparation.create_element_table(data.info) #unused? import build_backup as build #import build_viertel as build #import build_neumann as build #import build_ladung as build data.info.elements_per_line = -1 data.info.number_of_elements = build.get_number_of_elements() data.info.nodes_per_element = build.get_nodes_per_element() data.info.number_of_nodes = build.get_number_of_nodes() #create local_to_global table #data.tables.local_to_global = preparation.create_local_to_global(data.info) data.tables.local_to_global = build.get_local_to_global().copy() #create nodes_to_coordinates #data.tables.nodes_to_coordinates = preparation.create_nodes_to_coordinates(data.info) data.tables.nodes_to_coordinates = build.get_nodes_to_coordinates().copy() #print data.tables.nodes_to_coordinates #neumann #data.tables.edge_to_global = build.get_edge_to_global().copy() #create boundary_table #data.tables.boundary_table = preparation.create_boundary_table(data.info) data.tables.boundary_table = build.get_boundary_table().copy() helper.write_matrix_to_file(data.tables.local_to_global, 'data/local_to_global.txt') helper.write_matrix_to_file(data.tables.nodes_to_coordinates, 'data/nodes_to_coordinates.txt') helper.write_matrix_to_file(data.tables.boundary_table, 'data/boundary_table.txt') with Timer('assembly'): #assemble equations data.equ = assembly.assemble_equations(data.info, data.tables) pass with Timer('solve'): #solve equations data.equ.u_h = solve.solve(data.equ) helper.write_matrix_to_file(data.equ.u_h, 'data/u_h.txt') print(data.equ.u_h) with Timer('plots'): #generate plot_data # data.plots.xx, data.plots.yy, data.plots.zz = plots.generate_plot_data(data.info, # data.tables, data.plots, data.equ.u_h) #plots.contour_plot(data.info, data.tables, data.plots, data.equ.u_h) plots.contour_plot_new(data.info, data.tables, data.plots, data.equ.u_h) #plots.fe_plot(data.info, data.tables, data.plots) pass
#End Configuration ############################################ numStates = 23 #(11 * 11 * 2 + 1 for terminal state) if not SIMULATION: mt = RealMT(numberOfProblems, AWSAKID, AWSSAK, sandbox = SANDBOX) else: mt = SimMT(numberOfProblems,workerPools,OFFSET) (costs, answers) = solve(mt, numStates, numberOfProblems, workerPools, nameOfTask, VALUE, PRICE, GAMMA, SCALEFACTOR, ZMDPPATH, URL, EMPATH, fastLearning, timeLearning, taskDuration, debug) print "Average Cost:" print average(costs) print "Answers:" print answers for problemNumber in xrange(numberOfProblems): print "The answer to problem %d is %d and it cost %f." % (problemNumber,answers[problemNumber],costs[problemNumber])