def fit(self, tthmin=0, tthmax=180):
""" Apply simplex to improve fit of obs/calc tth """
tthmin = float(tthmin)
tthmax = float(tthmax)
import simplex
if self.theoryds == None:
self.addcellpeaks()
# Assign observed peaks to rings
self.wavelength = None
self.indices = [] # which peaks used
self.tthc = [] # computed two theta values
self.fitds = [] # hmm?
self.fit_tolerance = 1.
pars = self.parameterobj.get_parameters()
w = float(pars['wavelength'])
self.wavelength = w
self.fit_tolerance = float(pars['fit_tolerance'])
print "Tolerance for assigning peaks to rings", \
self.fit_tolerance, ", min tth", tthmin, ", max tth", tthmax
tth, eta = self.compute_tth_eta()
for i in range(len(self.theoryds)):
dsc = self.theoryds[i]
tthcalc = math.asin(dsc * w / 2) * 360. / math.pi # degrees
if tthcalc > tthmax:
break
elif tthcalc < tthmin:
continue
logicals = numpy.logical_and(
numpy.greater(tth, tthcalc - self.fit_tolerance),
numpy.less(tth, tthcalc + self.fit_tolerance))
if sum(logicals) > 0:
self.tthc.append(tthcalc)
self.fitds.append(dsc)
ind = numpy.compress(logicals, range(len(tth)))
self.indices.append(ind)
guess = self.parameterobj.get_variable_values()
inc = self.parameterobj.get_variable_stepsizes()
if len(guess) == 0:
# There is nothing to fit.
logging.warning("You try to fit with no variables!?")
return None
s = simplex.Simplex(self.gof, guess, inc)
newguess, error, niter = s.minimize()
inc = [v / 10 for v in inc]
guess = newguess
s = simplex.Simplex(self.gof, guess, inc)
newguess, error, niter = s.minimize()
self.parameterobj.set_variable_values(newguess)
self.wavelength = self.parameterobj.get("wavelength")
self.gof(newguess)
print newguess
def refinepositions(self, quiet=True, maxiters=100):
self.assignlabels()
ks = self.grains.keys()
ks.sort()
# assignments are now fixed
tolcache = self.tolerance
self.tolerance = 1.0
for key in ks:
g = key[0]
self.grains_to_refine = [key]
self.parameterobj.varylist = ['t_x', 't_y', 't_z']
self.set_translation(key[0], key[1])
guess = self.parameterobj.get_variable_values()
inc = self.parameterobj.get_variable_stepsizes()
s = simplex.Simplex(self.gof, guess, inc)
newguess, error, iter = s.minimize(maxiters=maxiters, monitor=1)
self.grains[key].translation[0] = self.parameterobj.parameters[
't_x']
self.grains[key].translation[1] = self.parameterobj.parameters[
't_y']
self.grains[key].translation[2] = self.parameterobj.parameters[
't_z']
print key, self.grains[key].translation,
self.refine(self.grains[key].ubi, quiet=False)
self.tolerance = tolcache
def test_result(self):
A = np.array([[1, 2, 2], [2, 1, 2], [2, 2, 1]])
b = np.array([0, 20, 20, 20])
c = np.array([-10, -12, -12])
s = my.Simplex(A, b, c, "MIN")
result = s.simplex(4)
self.assertTrue(np.array_equiv(result, np.array([4., 4., 4.])))
def start(self, c, b, A, arr_col, arr_row, F=0, level=0):
lvl = level + 1
step = simplex.Simplex(c, b, A, arr_col, arr_row, F)
# Проверка ошибки в Simplex
if step.brake:
_count = np.size(c) + np.size(b)
temp_value, index_value = self.fillValue(step)
index_branch = self.findFloat(temp_value)
# Все X - целочисленные, сравниваем с рекордом
if index_branch < 0:
self.match(temp_value)
# Если значение f(x) < рекордного, нет смысла идти дальше
elif temp_value[-1] < self.record_value[-1]:
pass
# Выполняем ветвление
else:
left = int(temp_value[index_branch])
print ("\n\tУровень:", lvl, "\tВЕТВЛЕНИЕ ВЛЕВО ПО", self.arr_col[index_branch], "<=", left)
self.addLimit(lvl, left, index_value[index_branch], _count, step, -1)
right = left + 1
print ("\n\tУровень:", lvl, "\tВЕТВЛЕНИЕ ВПРАВО ПО", self.arr_col[index_branch], ">=", right)
self.addLimit(lvl, right, index_value[index_branch], _count, step, 1)
pass
def test_feasible_start(self):
A = [[1, 1, 3], [2, 2, 5], [4, 1, 2]]
b = [30, 24, 36]
c = [3, 1, 2]
n = 3
m = 3
s = simplex.Simplex(A, b, c, n, m)
opt, ass = s.solve()
self.assertEqual(s.optimum, 28)
def test_infeasible_start(self):
A = [[2, -1], [1, -5]]
b = [2, -4]
c = [2, -1]
n = 2
m = 2
s = simplex.Simplex(A, b, c, n, m)
opt, ass = s.solve()
self.assertEqual(s.optimum, 2.0)
def test_time(self):
A = np.array([[1, 2, 2], [2, 1, 2], [2, 2, 1]])
b = np.array([0, 20, 20, 20])
c = np.array([-10, -12, -12])
s = my.Simplex(A, b, c, "MIN")
start = time.perf_counter()
_ = s.simplex(4)
stop = time.perf_counter()
self.assertGreater(0.005, stop - start)
def test_01(self):
debug = True
A = [[-1, -1], [1, 0], [0, 1]]
b = [-1, 2, 2]
c = [-1, 2]
n = 3
m = 2
s = simplex.Simplex(A, b, c, n, m)
opt, ass = s.solve()
self.assertEqual(s.optimum, 4.0)
def test_iter1(self):
A = np.array([[1, 2, 2], [2, 1, 2], [2, 2, 1]])
b = np.array([0, 20, 20, 20])
c = np.array([-10, -12, -12])
test_itr_1 = np.array([[120.0, -4.0, 0.0, 0.0, 6.0, 0.0, 0.0],
[10.0, 0.5, 1.0, 1.0, 0.5, 0.0, 0.0],
[10.0, 1.5, 0.0, 1.0, -0.5, 1.0, 0.0],
[0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0]])
s = my.Simplex(A, b, c, "MIN")
pass1 = s.optimize()
self.assertTrue(np.array_equiv(pass1, test_itr_1))
def setup_model(self, ):
""" Simple function for providing test data """
A = [[1, 1, -1, 0, 0, 1, 0], [2, -1, 0, -1, 0, 0, 1],
[0, 3, 0, 0, 1, 0, 0]]
b = [1, 1, 2]
c = [3, 0, -1, -1, 0, 0, 0, 2]
model = simplex.Simplex()
model.add_constraints(A, b)
model.add_objective(c, False)
return model
def test_iter2(self):
A = np.array([[1, 2, 2], [2, 1, 2], [2, 2, 1]])
b = np.array([0, 20, 20, 20])
c = np.array([-10, -12, -12])
test_itr_2 = np.array([
[120.0, 0.0, 0.0, -4.0, 2.0, 0.0, 4.0],
[10.0, 0.0, 1.0, 1.5, 1.0, 0.0, -0.5],
[10.0, 0.0, 0.0, 2.5, 1.0, 1.0, -1.5],
[0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0],
])
s = my.Simplex(A, b, c, "MIN")
s.optimize()
pass2 = s.optimize()
self.assertTrue(np.array_equiv(pass2, test_itr_2))
def main():
try:
logname = 'best_{}.log'.format(fit_type)
with open(logname, 'rb') as best_file:
reader = csv.reader(best_file, dialect='excel-tab')
p0 = []
for val in reader.next():
p0.append(np.float(val))
p0 = np.array(p0)
ranges = p0 * 0.02
s = simplex.Simplex(evaluate, p0, ranges)
p, err, iter = s.minimize(epsilon=0.00001, maxiters=2000, monitor=0)
with open(logname, 'a') as save_file:
writer = csv.writer(save_file, dialect='excel-tab')
writer.writerow(p)
writer.writerow([ssn, err])
except Exception as e:
print(e)
def fit(self, maxiters=100):
"""
Fit the global parameters
"""
self.assignlabels()
guess = self.parameterobj.get_variable_values()
inc = self.parameterobj.get_variable_stepsizes()
names = self.parameterobj.varylist
self.printresult(guess)
self.grains_to_refine = self.grains.keys()
self.recompute_xlylzl = False
for n in names:
if n not in ['t_x', 't_y', 't_z']:
self.recompute_xlylzl = True
inc = self.estimate_steps(self.gof, guess, inc)
s = simplex.Simplex(self.gof, guess, inc)
newguess, error, iter = s.minimize(maxiters=maxiters, monitor=1)
print
print "names", names
print "ng", newguess
for p, v in zip(names, newguess):
# record results
self.parameterobj.set(p, v)
print "Setting parameter", p, v
trans = ["t_x", "t_y", "t_z"]
for t in trans:
if t in names:
i = trans.index(t)
# imply that we are using this translation value, not the
# per grain values
# This is a f*cking mess - translations should never have been
# diffractometer parameters
for g in self.getgrains():
self.grains[g].translation[i] = newguess[names.index(t)]
print g, t, i, newguess[names.index(t)]
print
self.printresult(newguess)
def initBasicSet(self):
m, n = self.A.shape
auxiliary = simplex.Simplex(
list(np.sum(self.A, axis=0)) + [0] * m + [sum(self.b)])
MI = [0] * m
for i in range(m):
MI[i] = 1
auxiliary.add_constraint(list(self.A[i]) + MI, self.b[i])
MI[i] = 0
auxiliary.set_index(list(range(n + 1, n + m + 1)))
print("<----- Begin The Auxiliary LP ----->")
auxiliary.solveStandard(10)
auxiliary.print_info()
print("<----- Finish The Auxiliary LP ----->")
obj = auxiliary.table[0, -1]
if obj > simplex.eps:
print("It is not feasible!")
else:
j = 1
for i in range(m):
if auxiliary.index[i] > n:
while auxiliary.map_index[j]:
j += 1
auxiliary.pivot(auxiliary.index[i], j)
self.table = np.hstack(
(auxiliary.table[:, :n + 1], auxiliary.table[:, -1:]))
self.table[0] = np.array([[1] + list(self.cT * -1) + [0.0]
]).astype(np.float)
self.set_index(auxiliary.index[1:])
for i in range(1, n):
if self.map_index[i] > 0:
self.table[0] -= self.table[
self.map_index[i]] * self.table[0, i]
return
def run_loop_input(self, lines, score=None):
lines_iterator = iter(lines)
while True:
try:
line = next(lines_iterator)
except StopIteration:
return self.ff
cols = line.split()
if cols[0] == 'DIR':
self.direc = cols[1]
if cols[0] == 'FFLD':
# Import FF data.
if cols[1] == 'read':
if cols[2] == 'mm3.fld':
self.ff = datatypes.MM3(
os.path.join(self.direc, cols[2]))
if 'prm' in line:
self.ff = datatypes.TinkerFF(
os.path.join(self.direc, cols[2]))
if 'frcmod' in line:
self.ff = datatypes.AmberFF(
os.path.join(self.direc, cols[2]))
self.ff.import_ff()
self.ff.method = 'READ'
with open(os.path.join(self.direc, cols[2]), 'r') as f:
self.ff.lines = f.readlines()
# Export FF data.
if cols[1] == 'write':
self.ff.export_ff(os.path.join(self.direc, cols[2]))
# Trim parameters.
if cols[0] == 'PARM':
logger.log(20, '~~ SELECTING PARAMETERS ~~'.rjust(79, '~'))
self.ff.params = parameters.trim_params_by_file(
self.ff.params, os.path.join(self.direc, cols[1]))
if cols[0] == 'LOOP':
# Read lines that will be looped over.
inner_loop_lines = []
line = next(lines_iterator)
while line.split()[0] != 'END':
inner_loop_lines.append(line)
line = next(lines_iterator)
# Make loop object and populate attributes.
loop = Loop()
loop.convergence = float(cols[1])
loop.direc = self.direc
loop.ff = self.ff
loop.args_ff = self.args_ff
loop.args_ref = self.args_ref
loop.ref_data = self.ref_data
loop.loop_lines = inner_loop_lines
# Log commands.
pretty_loop_input(inner_loop_lines,
name='OPTIMIZATION LOOP',
score=self.ff.score)
# Run inner loop.
self.ff = loop.opt_loop()
# Note: Probably want to update this to append the directory given
# by the new DIR command.
if cols[0] == 'RDAT':
logger.log(20,
'~~ CALCULATING REFERENCE DATA ~~'.rjust(79, '~'))
if len(cols) > 1:
self.args_ref = ' '.join(cols[1:]).split()
self.ref_data = opt.return_ref_data(self.args_ref)
if cols[0] == 'CDAT':
logger.log(20, '~~ CALCULATING FF DATA ~~'.rjust(79, '~'))
if len(cols) > 1:
self.args_ff = ' '.join(cols[1:]).split()
self.ff.data = calculate.main(self.args_ff)
if cols[0] == 'COMP':
# Deprecated
# self.ff.score = compare.compare_data(
# self.ref_data, self.ff.data)
# if '-o' in cols:
# compare.pretty_data_comp(
# self.ref_data,
# self.ff.data,
# os.path.join(self.direc, cols[cols.index('-o') + 1]))
# if '-p' in cols:
# compare.pretty_data_comp(
# self.ref_data,
# self.ff.data,
# doprint=True)
output = False
doprint = False
r_dict = compare.data_by_type(self.ref_data)
c_dict = compare.data_by_type(self.ff.data)
r_dict, c_dict = compare.trim_data(r_dict, c_dict)
if '-o' in cols:
output = os.path.join(self.direc,
cols[cols.index('-o') + 1])
if '-p' in cols:
doprint = True
self.ff.score = compare.compare_data(r_dict,
c_dict,
output=output,
doprint=doprint)
if cols[0] == 'GRAD':
grad = gradient.Gradient(direc=self.direc,
ff=self.ff,
ff_lines=self.ff.lines,
args_ff=self.args_ff)
#### Should probably just write a function instead of looping
#### this for every gradient method. This includes everything
#### between the two lines of #. TR 20180112
##############################################################
for col in cols[1:]:
if "lstsq" in col:
g_args = col.split('=')[1].split(',')
for arg in g_args:
if arg == "True":
grad.do_lstsq = True
elif arg == False:
grad.do_lstsq = False
if 'radii' in arg:
grad.lstsq_radii = []
radii_vals = re.search(r"\[(.+)\]",
arg).group(1).split('/')
if radii_vals == "None":
grad.lstsq_radii = None
else:
for val in radii_vals:
grad.lstsq_radii.append(float(val))
if 'cutoff' in arg:
grad.lstsq_cutoff = []
cutoff_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if cutoff_vals == "None":
grad.lstsq_cutoff = None
else:
if len(cutoff_vals) > 2 or \
len(cutoff_vals) < 2:
raise Exception("Cutoff values must " \
"be between two numbers.")
for val in cutoff_vals:
grad.lstsq_cutoff.append(float(val))
elif "newton" in col:
g_args = col.split('=')[1].split(',')
for arg in g_args:
if arg == "True":
grad.do_newton = True
elif arg == False:
grad.do_newton = False
if 'radii' in arg:
grad.newton_radii = []
radii_vals = re.search(r"\[(.+)\]",
arg).group(1).split('/')
if radii_vals == 'None':
grad.newton_radii = None
else:
for val in radii_vals:
grad.newton_radii.append(float(val))
if 'cutoff' in arg:
grad.newton_cutoff = []
cutoff_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if cutoff_vals == 'None':
grad.newton_cutoff = None
else:
if len(cutoff_vals) > 2 or \
len(cutoff_vals) < 2:
raise Exception("Cutoff values must " \
"be between two numbers.")
for val in cutoff_vals:
grad.newton_cutoff.append(float(val))
elif "levenberg" in col:
g_args = col.split('=')[1].split(',')
for arg in g_args:
if arg == "True":
grad.do_levenberg = True
elif arg == False:
grad.do_levenberg = False
if 'radii' in arg:
grad.levenberg_radii = []
radii_vals = re.search(r"\[(.+)\]",
arg).group(1).split('/')
if radii_vals == 'None':
grad.levenberg_radii = None
else:
for val in radii_vals:
grad.levenberg_radii.append(float(val))
if 'cutoff' in arg:
grad.levenberg_cutoff = []
cutoff_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if cutoff_vals == 'None':
grad.levenberg_cutoff = None
else:
if len(cutoff_vals) > 2 or \
len(cutoff_vals) < 2:
raise Exception("Cutoff values must " \
"be between two numbers.")
for val in cutoff_vals:
grad.levenberg_cutoff.append(
float(val))
if 'factor' in arg:
grad.levenberg_cutoff = []
factor_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if factor_vals == 'None':
grad.levenberg_factor = None
else:
for val in factor_vals:
grad.levenberg_factor.append(
float(val))
elif "lagrange" in col:
g_args = col.split('=')[1].split(',')
for arg in g_args:
if arg == "True":
grad.do_lagrange = True
elif arg == False:
grad.do_lagrange = False
if 'radii' in arg:
grad.lagrange_radii = []
radii_vals = re.search(r"\[(.+)\]",
arg).group(1).split('/')
if radii_vals == 'None':
grad.lagrange_radii = None
else:
for val in radii_vals:
grad.lagrange_radii.append(float(val))
if 'cutoff' in arg:
grad.lagrange_cutoff = []
cutoff_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if cutoff_vals == 'None':
grad.lagrange_cutoff = None
else:
if len(cutoff_vals) > 2 or \
len(cutoff_vals) < 2:
raise Exception("Cutoff values must " \
"be between two numbers.")
for val in cutoff_vals:
grad.lagrange_cutoff.append(float(val))
if 'factor' in arg:
grad.lagrange_factors = []
factor_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if factor_vals == 'None':
grad.lagrange_factors = None
else:
for val in factor_vals:
grad.lagrange_factors.append(
float(val))
elif "svd" in col:
g_args = col.split('=')[1].split(',')
for arg in g_args:
if arg == "True":
grad.do_svd = True
elif arg == False:
grad.do_svd = False
if 'radii' in arg:
grad.svd_radii = []
radii_vals = re.search(r"\[(.+)\]",
arg).group(1).split('/')
if radii_vals == 'None':
grad.svd_radii = None
else:
for val in radii_vals:
grad.svd_radii.append(float(val))
if 'cutoff' in arg:
grad.svd_cutoff = []
cutoff_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if cutoff_vals == 'None':
grad.svd_cutoff = None
else:
if len(cutoff_vals) > 2 or \
len(cutoff_vals) < 2:
raise Exception("Cutoff values must " \
"be between two numbers.")
for val in cutoff_vals:
grad.svd_cutoff.append(float(val))
if 'factor' in arg:
grad.svd_cutoff = []
factor_vals = re.search(
r"\[(.+)\]", arg).group(1).split('/')
if factor_vals == 'None':
grad.svd_factor = None
else:
for val in factor_vals:
grad.svd_factor.append(float(val))
else:
raise Exception("'{}' : Not Recognized".format(col))
##############################################################
self.ff = grad.run(ref_data=self.ref_data)
if cols[0] == 'SIMP':
simp = simplex.Simplex(direc=self.direc,
ff=self.ff,
ff_lines=self.ff.lines,
args_ff=self.args_ff)
for col in cols[1:]:
if "max_params" in col:
simp.max_params = col.split('=')[1]
else:
raise Exception("'{}' : Not Recognized".format(col))
self.ff = simp.run(r_data=self.ref_data)
if cols[0] == 'WGHT':
data_type = cols[1]
co.WEIGHTS[data_type] = float(cols[2])
if cols[0] == 'STEP':
param_type = cols[1]
co.STEPS[param_type] = float(cols[2])
# MAIN
import numpy as np
import create
import simplex
import gomory
import output
# Вариант 18
c = np.array([7, 7, 6])
b = np.array([8, 2, 6])
A = np.array([[2, 1, 1], [1, 2, 0], [0, 0.5, 4]])
print("\nИсходная simplex-таблица\n")
obj = create.Create(c, b, A)
output.show(obj)
while (obj.gomory):
print("\nПреобразованная simplex-таблица\n")
simplex.Simplex(obj)
output.show(obj)
print("\nВызываем метод Гомори\n")
gomory.Gomory(obj)
output.show(obj)
pass
print("\nЦелосчисленное решение")
output.result(obj)
def run_loop_input(self, lines, score=None):
lines_iterator = iter(lines)
while True:
try:
line = lines_iterator.next()
except StopIteration:
return self.ff
cols = line.split()
if cols[0] == 'DIR':
self.direc = cols[1]
if cols[0] == 'FFLD':
# Import FF data.
if cols[1] == 'read':
self.ff = datatypes.MM3(os.path.join(self.direc, cols[2]))
self.ff.import_ff()
self.ff.method = 'READ'
with open(os.path.join(self.direc, cols[2]), 'r') as f:
self.ff.lines = f.readlines()
# Export FF data.
if cols[1] == 'write':
self.ff.export_ff(os.path.join(self.direc, cols[2]))
# Trim parameters.
if cols[0] == 'PARM':
logger.log(20, '~~ SELECTING PARAMETERS ~~'.rjust(79, '~'))
self.ff.params = parameters.trim_params_by_file(
self.ff.params, os.path.join(self.direc, cols[1]))
if cols[0] == 'LOOP':
# Read lines that will be looped over.
inner_loop_lines = []
line = lines_iterator.next()
while line.split()[0] != 'END':
inner_loop_lines.append(line)
line = lines_iterator.next()
# Make loop object and populate attributes.
loop = Loop()
loop.convergence = float(cols[1])
loop.direc = self.direc
loop.ff = self.ff
loop.args_ff = self.args_ff
loop.args_ref = self.args_ref
loop.ref_data = self.ref_data
loop.loop_lines = inner_loop_lines
# Log commands.
pretty_loop_input(inner_loop_lines,
name='OPTIMIZATION LOOP',
score=self.ff.score)
# Run inner loop.
self.ff = loop.opt_loop()
# Note: Probably want to update this to append the directory given
# by the new DIR command.
if cols[0] == 'RDAT':
logger.log(20,
'~~ CALCULATING REFERENCE DATA ~~'.rjust(79, '~'))
if len(cols) > 1:
self.args_ref = ' '.join(cols[1:]).split()
self.ref_data = opt.return_ref_data(self.args_ref)
if cols[0] == 'CDAT':
logger.log(20, '~~ CALCULATING FF DATA ~~'.rjust(79, '~'))
if len(cols) > 1:
self.args_ff = ' '.join(cols[1:]).split()
self.ff.data = calculate.main(self.args_ff)
if cols[0] == 'COMP':
self.ff.score = compare.compare_data(self.ref_data,
self.ff.data)
if '-o' in cols:
compare.pretty_data_comp(
self.ref_data, self.ff.data,
os.path.join(self.direc, cols[cols.index('-o') + 1]))
if '-p' in cols:
compare.pretty_data_comp(self.ref_data, self.ff.data)
if cols[0] == 'GRAD':
grad = gradient.Gradient(direc=self.direc,
ff=self.ff,
ff_lines=self.ff.lines,
args_ff=self.args_ff)
self.ff = grad.run(ref_data=self.ref_data)
if cols[0] == 'SIMP':
simp = simplex.Simplex(direc=self.direc,
ff=self.ff,
ff_lines=self.ff.lines,
args_ff=self.args_ff)
self.ff = simp.run(r_data=self.ref_data)
if cols[0] == 'WGHT':
data_type = cols[1]
co.WEIGHTS[data_type] = float(cols[2])
pygame.init()
screen = pygame.display.set_mode((500, 500))
pygame.display.set_caption('Biome Generation')
# We will see 50x50 blocks at any given time.
grid = [[0] * 50] * 50
# There will be three biomes in the terrain: desert, grass, and snowy. Each one is represented by its own color.
biome_colors = {
0: (255, 255, 0), # Yellow
1: (38, 108, 46), # Forest green
2: (255, 255, 255) # White
}
# Import an instance of our Perlin noise generator.
noise = simplex.Simplex()
# Ask the user what seed to use for the simulation.
seed = float(input('Enter the numerical seed: '))
screen.fill((255, 255, 255))
pygame.display.flip()
# Game loop
running = True
while running:
# Iterate through the biome list and determine the biome.
for x in range(left, 50 + left):
for y in range(top, 50 + top):
ans = noise.noise(x * .5 * seed, y * .5 * seed)
if ans < -0.3: # Deserts should be relatively uncommon
color = biome_colors[0]
def evaluate(p, ssn):
dummy_x = np.zeros(10)
dummy_y = np.zeros([10, 10])
data = [[dummy_x, dummy_y, dummy_y], [dummy_x, dummy_y, dummy_y]]
if fit_type is 'global' or fit_type is 20: # 20 MHz data
sim = PSim.DecaySim(reprate=20000000, tolerance=0.005, step=5e-12)
sim.trap = p[0]
sim.EHdecay = p[1] * sim.step
sim.Etrap = p[2] * sim.step
sim.FHloss = p[3] * sim.step
sim.Gdecay = p[4] * sim.step
sim.G2decay = p[5] * sim.step
sim.G3decay = p[6] * sim.step
sim.GHdecay = p[7] * sim.step
sim.Gescape = p[8] * sim.step
sim.Gform = p[9] * sim.step
sim.G3loss = p[10] * sim.step
sim.scalar = 1
for power in powers:
sim.addPower(power)
sim.runSim()
interp_signals = []
for this_run in sim.signal:
interp_this = np.interp(xarray, sim.xdata, this_run)
interp_signals.append(interp_this)
interp_signals = np.array(interp_signals)
data[0] = [xarray, yarrays, interp_signals]
if fit_type is 'global' or fit_type is 250: # 250 kHz data
sim_250 = PSim.DecaySim(reprate=250000, tolerance=0.005, step=5e-12)
sim_250.trap = p[0]
sim_250.EHdecay = p[1] * sim_250.step
sim_250.Etrap = p[2] * sim_250.step
sim_250.FHloss = p[3] * sim_250.step
sim_250.Gdecay = p[4] * sim_250.step
sim_250.G2decay = p[5] * sim_250.step
sim_250.G3decay = p[6] * sim_250.step
sim_250.GHdecay = p[7] * sim_250.step
sim_250.Gescape = p[8] * sim_250.step
sim_250.Gform = p[9] * sim_250.step
sim_250.G3loss = p[10] * sim_250.step
sim_250.scalar = 1
for power in powers_250:
sim_250.addPower(power)
sim_250.runSim()
interp_signals_250 = []
for this_run in sim_250.signal:
interp_this = np.interp(xarray_250, sim_250.xdata, this_run)
interp_signals_250.append(interp_this)
interp_signals_250 = np.array(interp_signals_250)
data[1] = [xarray_250, yarrays_250, interp_signals_250]
# Use a simplex minimization to find the best scalar
scalar0 = np.array([8e-21])
ranges = scalar0*0.1
s = simplex.Simplex(scalar_min, scalar0, ranges)
values, fitness, iter = s.minimize(epsilon=0.00001, maxiters=500,
monitor=0, data=data)
scalar = values[0]
p[-1] = scalar
if scalar < 0:
fitness = 1e30
with open(filename, 'a') as log_file:
writer = csv.writer(log_file, dialect="excel-tab")
row = [ssn, '{:.4e}'.format(fitness)]
for var in p:
row.append('{:.4e}'.format(var))
writer.writerow(row)
return fitness, scalar
print("ДАННЫЕ ВАРИАНТ №18")
print("c =", c)
print("b =", b)
print("A =", A)
# Программа
# Шаг 0 (Создаем массивы обозначений X для графического вывода)
x_col, x_row = marking.fillMarks(c, b)
F = 0
# Шаг 1 (Получаем значения F и Х-ов)
step_1 = simplex.Simplex(c, b, A, x_col, x_row)
default_param = np.array(x_col)
default_param = np.append(default_param, x_row)
default_value = np.zeros(np.size(default_param))
for i in range(np.size(step_1.arr_row)):
for j in range(np.size(default_param)):
if step_1.arr_row[i] == default_param[j]:
default_value[j] = step_1.table[i][0]
F = abs(default_value[-1])
default_table = PrettyTable()
default_table.field_names = [item for item in default_param]
default_table.add_row([item for item in default_value])
# ...........: Trabalho Pratico 1 :...........
# ...: Disciplina de Pesquisa Operacional :...
# .Autora: Fernanda Aparecida Rodrigues Silva.
# ............................................
# ...:Departamento de Ciencia da Computacao:..
# ...:Universidade Federal de Minas Gerais:...
# ............................................
# External Imports
import sys
# Internal Imports
import simplex
import input_treatment
if __name__ == '__main__':
file = input_treatment.InputTreatment()
verbose_mode = False
if(len(sys.argv) == 4):
if(sys.argv[3] == "--verbose"):
verbose_mode = True
lp = file.read_file(sys.argv[1], verbose_mode)
lp.turn_into_FPI(verbose_mode)
s = simplex.Simplex(lp)
s.solve_LP(verbose_mode)
file.write_file(sys.argv[2], lp)
