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 __init__(self, name, facility="solver"):
Solver.__init__(self, name, facility)
self.coupler = None
self.myPlus = []
self.remotePlus = []
return
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 checkpoint(self, checkpointFrequency):
Solver.checkpoint(self, checkpointFrequency)
if not (self.step % checkpointFrequency):
#TODO: checkpoint for coupler
pass
return
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 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
