def main(): # Take command line arguments parser = argparse.ArgumentParser() # parser.add_argument("input", help="Input file"); parser.add_argument("-i", "--input", required=True, help="input file") parser.add_argument("-v", "--verbose", help="verbose mode", action="store_true") parser.add_argument("-s", "--solver", choices=["sat", "csp", "asp", "ilp", "prop"], default="prop", help="selects which solver to use (default: prop)") args = parser.parse_args(map(lambda x: x.lower(), sys.argv[1:])) input = args.input verbose = args.verbose solver = args.solver # Read sudoku from input file if verbose: print("Reading sudoku from " + input + "..") k, sudoku = read_sudoku_from_file(input) if sudoku == None: print("Exiting..") return # Print information, in verbose mode if verbose: print("Input sudoku:") print(pretty_repr(sudoku, k)) # Solve the sudoku using the selected solver solved_sudoku = None if solver == "sat": timer = Timer(name="solving-time", text="Did SAT encoding & solving in {:.2f} seconds") if verbose: print("Solving sudoku using the SAT encoding..") timer.start() # with suppress_stdout_stderr(): solved_sudoku = solve_sudoku_SAT(sudoku, k) if verbose: timer.stop() elif solver == "csp": timer = Timer(name="solving-time", text="Did CSP encoding & solving in {:.2f} seconds") if verbose: print("Solving sudoku using the CSP encoding..") timer.start() # with suppress_stdout_stderr(): solved_sudoku = solve_sudoku_CSP(sudoku, k) if verbose: timer.stop() elif solver == "asp": timer = Timer(name="solving-time", text="Did ASP encoding & solving in {:.2f} seconds") if verbose: print("Solving sudoku using the ASP encoding..") timer.start() # with suppress_stdout_stderr(): solved_sudoku = solve_sudoku_ASP(sudoku, k) if verbose: timer.stop() elif solver == "ilp": timer = Timer(name="solving-time", text="Did ILP encoding & solving in {:.2f} seconds") if verbose: print("Solving sudoku using the ILP encoding..") timer.start() # with suppress_stdout_stderr(): solved_sudoku = solve_sudoku_ILP(sudoku, k) if verbose: timer.stop() elif solver == "prop": timer = Timer( name="solving-time", text="Did recursive solving with propagation in {:.2f} seconds") if verbose: print("Solving sudoku using recursion and propagation..") timer.start() # with suppress_stdout_stderr(): solved_sudoku = solve_sudoku_prop(sudoku, k) if verbose: timer.stop() # Print the solved sudoku if solved_sudoku == None: print("NO SOLUTION FOUND") else: if check_solved_sudoku(solved_sudoku, k) == True: print(pretty_repr(solved_sudoku, k)) else: print("INCORRECT SOLUTION FOUND") print(pretty_repr(solved_sudoku, k))
def train_loop( self, *, model, config, writer, kfp_writer, train_dataloader, label_mappings, val_dataloader, train_sampler=None, ): """ Args: model: model to train config (CfgNode): estimator config writer: Tensorboard writer object device: model training on device (cpu|cuda) train_dataloader (torch.utils.data.DataLoader): label_mappings (dict): a dict of {label_id: label_name} mapping val_dataloader (torch.utils.data.DataLoader): """ model = model.to(self.device) params = [p for p in model.parameters() if p.requires_grad] if config.optimizer.name == "Adam": optimizer = torch.optim.Adam(params, **config.optimizer.args) # use fixed learning rate when using Adam lr_scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lambda x: 1.0) elif config.optimizer.name == "SGD": optimizer = torch.optim.SGD( params, lr=config.optimizer.args.lr, momentum=config.optimizer.args.momentum, weight_decay=float(config.optimizer.args.weight_decay), ) lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer, step_size=config.optimizer.args.lr_step_size, gamma=config.optimizer.args.lr_gamma, ) else: raise ValueError(f"only valid optimizers are 'SGD' and 'Adam' but " f"received paramater {config.optimizer.name}") accumulation_steps = config.train.get("accumulation_steps", DEFAULT_ACCUMULATION_STEPS) logger.debug("Start training") total_timer = Timer(name="total-time", text=const.TIMING_TEXT, logger=logging.info) total_timer.start() for epoch in range(config.train.epochs): with Timer( name=f"epoch-{epoch}-train-time", text=const.TIMING_TEXT, logger=logging.info, ): train_one_epoch( writer=writer, model=model, optimizer=optimizer, data_loader=train_dataloader, device=self.device, epoch=epoch, lr_scheduler=lr_scheduler, accumulation_steps=accumulation_steps, log_frequency=self.config.train.log_frequency, ) if self.config.system.distributed: train_sampler.set_epoch(epoch) self.checkpointer.save(self, epoch=epoch) with Timer( name=f"epoch-{epoch}-evaluate-time", text=const.TIMING_TEXT, logger=logging.info, ): evaluate_per_epoch( model=model, data_loader=val_dataloader, device=self.device, writer=writer, kfp_writer=kfp_writer, epoch=epoch, metrics=self.metrics, label_mappings=label_mappings, ) total_timer.stop()
from storer.fileops.filecopier import CopyTask from codetiming import Timer # https://github.com/realpython/codetiming from datetime import datetime, timedelta SOURCE_PATH = "/home/jfcm02/Proyectos/Desarrollo/TestData/source_files" DESTINATION_PATH = "/home/jfcm02/Proyectos/Desarrollo/TestData/dest_files" # filecmp.dircmp(SOURCE_PATH,DESTINATION_PATH).report() copia1 = CopyTask(SOURCE_PATH, DESTINATION_PATH, pbar=True) print(copia1) print(r"Número de Ficheros en {} = {}".format(SOURCE_PATH, len(copia1.sourcefiles))) print("Tamaño total de la carpeta origen: {:.2f}MBs".format(round(copia1.totalsize/1024/1024, 2))) t = Timer(name="class", logger=None) t.start() # copia1.do_copy() # copia1.do_copy(datetime.strptime("2019/01/01", "%Y/%m/%d")) # copia1.do_copy(to_date=datetime.strptime("2019/01/01", "%Y/%m/%d")) copia1.do_copy(datetime.strptime("2019/01/01", "%Y/%m/%d"), datetime.strptime("2019/01/31", "%Y/%m/%d")) elapsed_time = t.stop() print("Ficheros seleccionados para copiar: {} ({:.2f}MBs)".format(len(copia1.selectedfiles), round(copia1.selectedsize/1024/1024, 2))) print("Ficheros con mismo nombre pero distintos (renombrar): {}".format(copia1.renamedfiles)) print("Ficheros idénticos (saltar): {}".format(copia1.skippedfiles)) print("Ficheros copiados: {} (tamaño: {:.2f}MBs)".format(copia1.copiedfiles, round(copia1.copiedsize/1024/1024, 2))) print("Tiempo transcurrido: {:.4f} segundos".format(round(elapsed_time, 4)))
label='Prominent Peaks') # Sub plot one minima identification # plt.scatter(self.peaks_x, self.eval_height, color = 'black', s = 5, marker = 'X', label = 'Eval_height') # plt.scatter(self.intersect_x, self.intersect_y, color = 'orange', s = 5, marker = 'o', label = 'Intercetion') plt.vlines(self.prom_x, self.prom_y_min, self.prom_y_max, color='black', linewidth=1, linestyle='dashed', label='Peak Prominence') # plt.hlines(self.prom_y_min, self.min_pwidth, self.max_pwidth, color='green') fig.legend() fig.suptitle("FT-IR Spectra Comparison") plt.xlabel('Wavenumber (cm-1)') plt.ylabel("Reflectance") plt.ylim(0.00, 1.20) plt.show() # ----- Main Loop ----- print("---------- START ----------") pri_spectra = Spectra(file_import_selection()) pri_spectra.x_y_assignment() pri_spectra.x_axis_limiting() pri_spectra.baseline_correction() pri_spectra.peak_profile_generation() pri_spectra.plot() print("-----------END-----------") # ----- End Timer ----- t.stop()
distance[i][k] + distance[k][j]) #print(distance) #print_solution(distance) # Printing the solution def print_solution(distance): for i in range(nV): for j in range(nV): if (distance[i][j] == INF or distance[i][j] > 9000): print("INF", end=" ") else: print(distance[i][j], end=" ") print(" ") G = loadGraph('testExample.txt') nV = len(G) ''' G = [[0, 5, INF, 10], [INF, 0, 3, INF], [INF, INF, 0, 1], [INF, INF, INF, 0] ] nV=len(G) ''' floyd_warshall(G) #t.stop() vraća lijepo formatiran rezultat pa nije potreban print execution_time = t.stop()
def test_error_if_timer_not_running(): """Test that timer raises error if it is stopped before started""" t = Timer(text=TIME_MESSAGE) with pytest.raises(TimerError): t.stop()
class Merge(object): def __init__(self, indb=None, outdb=None, host=None): """Load a small bounding box for each country using the modified raw_countries table. Included in the source code for osm-stats-workers is a GeoJson file with the boundries used to display country boundaries. As those boundaries were only used by the front end, the boundaries are not in the database. The modified raw_countries table is the same data with a new column added for the geometry.""" if indb is None: indb = "leaderboard" self.indb = Pydb(indb, host) self.countries = dict() geoquery = "SELECT id,St_AsText(ST_Envelope(ST_Buffer(ST_Centroid(boundary), 1, 4))) FROM raw_countries;" log = PixelSpinner("Loading Country boundaries...") self.indb.dbcursor.execute(geoquery) for row in self.indb.dbcursor.fetchall(): log.next() self.countries[row[0]] = row[1] self.timer = Timer() if outdb is None: outdb = "galaxy" self.outdb = Pydb(outdb, host) def getBbox(self, cid): """Get the bounding box for a country""" if cid in self.countries: return self.countries[cid] else: return None def mergeUsers(self): """Merge the raw_users table from the leaderboard into osmstats""" inquery = "SELECT id,name FROM raw_users;" logging.info( "Merging leaderboard user table into Galaxy osmstats database") self.indb.dbcursor.execute(inquery) for entry in self.indb.dbcursor.fetchall(): outquery = "INSERT INTO users(id,name) VALUES({id}, \'{name}\') ON CONFLICT(id) DO UPDATE SET id=" # watch out for single quotes in user names value = entry[1].replace("'", "'") outquery += str(entry[0]) + ", name=\'" + value + "\'" query = outquery.format(id=int(entry[0]), name=value) self.outdb.dbcursor.execute(query) def mergeHashtags(self): """Merge the raw_hashtags table from the leaderboard into osmstats""" log = PixelSpinner( "Merging leaderboard hashtags table into Galaxy osmstats database. this may take a will..." ) self.timer.start() inquery = "SELECT changeset_id,hashtag FROM raw_changesets_hashtags INNER JOIN raw_hashtags ON (raw_changesets_hashtags.hashtag_id = id);" self.indb.dbcursor.execute(inquery) self.timer.stop() for entry in self.indb.dbcursor.fetchall(): log.next() outquery = "INSERT INTO changesets(id,hashtags) VALUES({id}, ARRAY['{hashtags}']) ON CONFLICT(id) DO UPDATE SET id=" # watch out for single quotes in user names fixed = entry[1].replace("'", "'") outquery += str( entry[0] ) + ", hashtags=ARRAY_APPEND(changesets.hashtags, '" + fixed + "')" self.outdb.dbcursor.execute( outquery.format(id=int(entry[0]), hashtags=fixed)) def mergeStatistics(self, timestamp): """Merge the raw_changesets table from the leaderboard into osmstats""" log = PixelSpinner( "Merging leaderboard statistics into Galaxy osmstats database") log.next() self.timer.start() query = "SELECT id, road_km_added, road_km_modified, waterway_km_added, waterway_km_modified, roads_added, roads_modified, waterways_added, waterways_modified, buildings_added, buildings_modified, pois_added, pois_modified, editor, user_id, created_at, closed_at, updated_at,country_id FROM raw_changesets INNER JOIN raw_changesets_countries ON (raw_changesets_countries.changeset_id = id);" self.indb.dbcursor.execute(query) self.timer.stop() result = self.indb.dbcursor.fetchone() while result is not None: stats = dict() added = dict() modified = dict() # non statistics fields stats['change_id'] = result[0] stats['editor'] = result[11] stats['user_id'] = result[14] stats['created_at'] = result[15] stats['closed_at'] = result[16] if stats['created_at'] is None and stats['closed_at'] is None: result = self.indb.dbcursor.fetchone() continue if stats['created_at'] is None: stats['created_at'] = stats['closed_at'] if stats['closed_at'] is None: stats['closed_at'] = stats['created_at'] stats['updated_at'] = result[17] stats['country_id'] = result[18] if self.getBbox(result[18]) is None: logging.warning( "Country ID %s is not in the geoboundaries table" % result[18]) result = self.indb.dbcursor.fetchone() continue stats['bbox'] = "ST_Multi(ST_GeomFromText('" stats['bbox'] += self.getBbox(result[18]) + "')" # Added fields added['highway_km'] = result[1] added['waterway_km'] = result[3] added['highways'] = result[4] added['waterways'] = result[7] added['buildings'] = result[9] added['pois'] = result[11] # Modified fields modified['highway_km'] = result[2] modified['waterway_km'] = result[4] modified['highways'] = result[6] modified['waterways'] = result[8] modified['buildings'] = result[10] modified['pois'] = result[12] # Get the next row, since we're done with this one result = self.indb.dbcursor.fetchone() # Build the hstore for the added statistics hadd = "HSTORE(ARRAY[" for key, value in added.items(): hadd += "ARRAY['" + key + "','" + str(value) + "']," length = len(hadd) - 1 hadd = hadd[:length] hadd += "])" # Build the hstore for the added statistics hmod = "HSTORE(ARRAY[" for key, value in modified.items(): hmod += "ARRAY['" + key + "','" + str(value) + "']," length = len(hmod) - 1 hmod = hmod[:length] hmod += "])" query = "INSERT INTO changesets(id, editor, user_id, created_at, closed_at, updated_at, added, modified, bbox)" query += " VALUES({id}, '{editor}', {user_id}, '{created_at}', '{closed_at}', '{updated_at}', {add}, {mod}, {bbox})) ON CONFLICT(id) DO UPDATE SET editor='{editor}', user_id={user_id}, created_at='{created_at}', closed_at='{closed_at}', updated_at='{updated_at}', added={add}, modified={mod}, bbox={bbox});" outquery = query.format(id=stats['change_id'], editor=stats['editor'], user_id=stats['user_id'], created_at=stats['created_at'], closed_at=stats['closed_at'], updated_at=stats['updated_at'], bbox=stats['bbox'], add=hadd, mod=hmod) #print(outquery) self.outdb.dbcursor.execute(outquery)
handles, labels = axs2[0, 0].get_legend_handles_labels() fig2.legend(handles, labels, loc='upper right') peak_plotting_t.stop() plt.show() # Main Loop - Processing the spectrum print("---------- START ----------") # TODO: Add method to init all functions within the class (automate) # Assigning spectrum object names pri_spectrum = Spectrum('Import') sec_spectrum = Spectrum('reference') pri_spectrum.file_import_selection() pri_spectrum.x_y_assignment() pri_spectrum.x_axis_limiting() pri_spectrum.normalise_data() pri_spectrum.peak_detection() pri_spectrum.peak_deconvolution() pri_spectrum.peak_comparison() # pri_spectrum.spectrum_peak_output() # sec_spectrum.file_import_selection() # sec_spectrum.x_y_assignment() # sec_spectrum.x_axis_limiting() # sec_spectrum.normalise_data() # sec_spectrum.peak_detection() # sec_spectrum.peak_deconvolution() # sec_spectrum.peak_comparison() pri_spectrum.plot() total_runtime_t.stop() print("-----------END-----------")
class Binary_ILP_case: # variables: list of sympy symbols # obj_fn [sympy expression]: the function to maximize or minimize # b: array of constraints def __init__(self, variables, obj_fn, b, maximize=True, expected_obj_val=None): # init self.variables = variables self.obj_fn = obj_fn self.b = b # all inEquality functions must be less than for now. self.expected_obj_val = expected_obj_val self._variables = [] self._obj_fn = obj_fn self._b = b[:] self.var_ref = {} # True means _xi = xi, False means _xi = (1-xi) self.counter_var_ref = {} # get x1 from _x1 self.i = 0 self.algo = self.get_supported_algos() self.goal = 'maximize' if (maximize == False): self.goal = 'minimize' self.timer = Timer(name="class", logger=None) self.pre_process() def __repr__(self): # for shell return self.get_print_string() def __str__(self): # for print return self.get_print_string() def get_print_string(self): variables = '' for var in self.variables: variables += str(var) + ', ' variables = variables[:-2] result = 'Case:'.ljust(10) + variables + '\n' result += 'Z:'.ljust(10) + str(self.obj_fn) + '\n\n' first_line = True for inEq in self.b: if first_line: result += 'b:'.ljust(10) + str(inEq) + '\n' first_line = False else: result += ''.ljust(10) + str(inEq) + '\n' result += '\n' if self.expected_obj_val: result += 'Exp val:'.ljust(10) + str(self.expected_obj_val) return result def pre_process(self): # print('pre_processing...') self.covert_all_constraints_to_less_than() # update variable reference and objective fxn reference obj_args = self.obj_fn.args # when calling args, sympy will change the order of variables appearing in expression with the constant at the first place, and # some arbitary order for the rest of the variables for var in self.variables: _var = "_" + str(var) _var = Symbol(_var) self._variables.append(_var) self.counter_var_ref[_var] = var self.var_ref[var] = VarRef(_var, False) for item in obj_args: if not isinstance(item, numbers.Integer): if not isinstance(item, symbol.Symbol): coeff = item.args[0] var = item.args[1] else: coeff = 1 var = item _var = self.var_ref[var].counter_part if coeff > 0: self.var_ref[var] = VarRef(_var, True) # True for isReverse self._obj_fn = self._obj_fn.subs(var, (1 - _var)) self._b = self.get_substitute_b(self._b, var, (1 - _var)) else: self._obj_fn = self._obj_fn.subs(var, _var) self._b = self.get_substitute_b(self._b, var, _var) # print('vars:', self.variables) # print('_vars', self._variables) # print('var_ref', self.var_ref) # print('obj_fn', self.obj_fn) # print('_obj_fn', self._obj_fn) # print('b', self.b) # print('_b', self._b) # print('counter_far_ref', self.counter_var_ref) # print('\n\n') def translate_result(self, result): # print('translating result...') # print('result', result) if result.obj_val == -oo: return result var_vals_ref = {} for item in result.var_vals: _var = item.var val = item.val var = self.counter_var_ref[_var] if self.var_ref[var].isReverse: var_vals_ref[var] = 1 - val else: var_vals_ref[var] = val # print('var_vals_ref', var_vals_ref) sorted_var_vals = [] #based on order of vars # print('self.vars', self.variables) for var in self.variables: sorted_var_vals.append(VarVal(var, var_vals_ref[var])) return Result(result.obj_val, sorted_var_vals) def covert_all_constraints_to_less_than(self): # print('start covert_all_constraints_to_less_than', self._b) _b = [] for inEq in self._b: # print('inEqu is: ', inEq) if isinstance(inEq, (StrictLessThan, LessThan)): _b.append(inEq) else: _b.append(inEq.reversedsign) self._b = _b def _(self, var): return self.var_ref[var].counter_part def get_preprocessed_result(self): return { '_variables': self._variables, '_obj_fn': self._obj_fn, '_b': self._b } def get_supported_algos(self): class Algo: def __init__(self): self.brutal_divide_and_conquer = 'brutal_divide_and_conquer' self.brutal_explicit_enumeration = 'brutal_explicit_enumeration' self.implicit_enumeration = 'implicit_enumeration' return Algo() def reset_counter(self): self.i = 0 def get_run_count(self): return self.i def get_substitute_b(self, old_b, var, val): # to do: add check in this fxn, if result is false, the function that call this function should stop evaluate this possibility # print('calc get_substitute_b,', old_b, var, val) # val could be value, or the counter part of var # example: get_substitute_b(b, x1, (1-_x1)) result = [] for inEq in old_b: result.append(inEq.subs(var, val)) # print('sub b result', result) return result def is_feasible(self, b, var_vals, debug=False): # if debug: # print('checking is feasible, b:', b, ' var_vals:', var_vals) for constraint in b: c = constraint for var_val in var_vals: c = c.subs(var_val.var, var_val.val) if c == False: # if debug: # print('\nConstraint not met: ', constraint, ' with var vals: ', var_vals, '\n') return False if debug: print('\nFeasible, retunning true !!!\n') print('b:', b, ' var_vals:', var_vals) return True def get_obj_fn_val(self, obj_fn, var_vals): obj_val = obj_fn for item in var_vals: obj_val = obj_val.subs(item.var, item.val) return obj_val def solve(self, algo, print_run_count=False): variables = self._variables[:] obj_fn = self._obj_fn b = self._b[:] self.reset_counter() self.timer.start() if algo == self.algo.brutal_divide_and_conquer: result = self.solve_by_brutal_divide_and_conquer( variables, obj_fn, b) if algo == self.algo.brutal_explicit_enumeration: result = self.solve_by_brutal_explicit_enumeration( variables, obj_fn, b) if algo == self.algo.implicit_enumeration: result = self.solve_by_implicit_enumeration(variables, obj_fn, b) elapsed_time = self.timer.stop() if print_run_count: print("Run count", self.get_run_count()) print("Runnint time - {algo} : {time:,.4f} second".format( algo=algo, time=elapsed_time)) return self.translate_result(result) def solve_by_brutal_divide_and_conquer(self, variables, obj_fn, b): self.i += 1 # if number of free vars is greater than 1, pick one var, update objective function and inequality constraints if len(variables) > 1: fix_var = variables[0] # modify vars list obj_zero = obj_fn.subs(fix_var, 0) b_zero = self.get_substitute_b(b, fix_var, 0) result_zero = self.solve_by_brutal_divide_and_conquer( variables[1:], obj_zero, b_zero) obj_one = obj_fn.subs(fix_var, 1) b_one = self.get_substitute_b(b, fix_var, 1) result_one = self.solve_by_brutal_divide_and_conquer( variables[1:], obj_one, b_one) if result_zero.obj_val > result_one.obj_val: return Result(obj_val=result_zero.obj_val, var_vals=[VarVal(var=fix_var, val=0)] + result_zero.var_vals) else: # print('result_one', fix_var, obj_fn) return Result(obj_val=result_one.obj_val, var_vals=[VarVal(var=fix_var, val=1)] + result_one.var_vals) else: # base case var = variables[0] is_feasible_zero = self.is_feasible(b, [VarVal(var, 0)]) if not is_feasible_zero: obj_val_zero = -oo else: obj_val_zero = obj_fn.subs(var, 0) is_feasible_one = self.is_feasible(b, [VarVal(var, 1)]) if not is_feasible_one: obj_val_one = -oo else: obj_val_one = obj_fn.subs(var, 1) if obj_val_zero > obj_val_one: result = Result(obj_val=obj_val_zero, var_vals=[VarVal(var=var, val=0)]) else: result = Result(obj_val=obj_val_one, var_vals=[VarVal(var=var, val=1)]) # print('result', result) return result def solve_by_brutal_explicit_enumeration(self, variables, obj_fn, b): all_cases = list(product([0, 1], repeat=len(variables))) best_result = Result(obj_val=-oo, var_vals=[]) for case in all_cases: var_vals = [] for i in range(0, len(variables)): var_vals.append(VarVal(variables[i], case[i])) obj_val = self.get_obj_fn_val(obj_fn, var_vals) self.i += 1 if obj_val > best_result.obj_val and self.is_feasible(b, var_vals): best_result = Result(obj_val, var_vals) return best_result def sort_vars_by_priority_for_implicit_enumeration(self, variables): # to be implemented return variables def solve_by_implicit_enumeration(self, variables, obj_fn, b): # implicit enumeration assume all vars has a negative coefficient in objective function and thus best obj val will be set all vars to 0 debug = False self.i += 1 # print('running with vars:', variables) # print('fn:', obj_fn) # print('b:', b) best_result = Result(obj_val=-oo, var_vals=[]) fix_var = variables.pop(0) # branch to fix_var = 0 var_vals = [VarVal(fix_var, 0)] for var in variables: var_vals.append(VarVal(var, 0)) if self.is_feasible(b, var_vals, debug=debug): # best case scenario obj_val = self.get_obj_fn_val(obj_fn, var_vals) # print('all 0 is feasible, returning val:', obj_val) return Result(obj_val, var_vals) elif len(variables) > 0: # can be divided further obj_zero = obj_fn.subs(fix_var, 0) b_zero = self.get_substitute_b(b, fix_var, 0) result_zero = self.solve_by_implicit_enumeration( variables[:], obj_zero, b_zero) if result_zero.obj_val > best_result.obj_val: # print('best result updated from: ', best_result.obj_val, ' to: ', result_zero.obj_val) best_result = Result(result_zero.obj_val, [VarVal(fix_var, 0)] + result_zero.var_vals) # branch to fix_var = 1 var_vals[0].val = 1 if self.is_feasible(b, var_vals, debug=debug): obj_val = self.get_obj_fn_val(obj_fn, var_vals) if obj_val > best_result.obj_val: # print('best result updated from: ', best_result.obj_val, ' to: ', obj_val) best_result = Result(obj_val, var_vals) elif len(variables) > 0: obj_one = obj_fn.subs(fix_var, 1) b_one = self.get_substitute_b(b, fix_var, 1) result_one = self.solve_by_implicit_enumeration( variables[:], obj_one, b_one) if result_one.obj_val > best_result.obj_val: # print('best result updated from: ', best_result.obj_val, ' to: ', result_one.obj_val) best_result = Result(result_one.obj_val, [VarVal(fix_var, 1)] + result_one.var_vals) # print('\nreturning best result', best_result, '\n') return best_result