def get_solution(self) -> Graph: if self._graph.is_empty(): return Graph() solver = cp_model.CpSolver() solver.parameters.max_time_in_seconds = 60.0 status = solver.Solve(self._model) if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE: return self._solution_to_graph(solver) else: return Graph()
def __init__(self, view): self.__view = view self.__file_view = FileReader() self.__database_view = DatabaseView() self.__graph_view = Graph() self.__query_creator = QueryCreator() self.__logger = Logger() with open('src\config.json') as json_data_file: data = json.load(json_data_file) self.__serial_file = data['pickle']['file'] self.__database_name = data['mysql']['db']
def test_one_edge(concomp): msg = "{} failed".format(concomp.__name__) g = Graph() g.add_edge(0, 1) cc = concomp(g) assert len(cc) == 2, msg assert cc[0] == cc[1], msg
def readInput(): """First line contains two arguments n = number of vertices m = number of edges in the graph next m line conatins (a,b) reresenting an edge.""" n, m = map(int, raw_input().split(" ")) edges = [] for i in range(0, m): a, b = map(int, raw_input().split(" ")) edges.append((a, b)) graph = Graph(n, m, edges) print graph.toString()
def readInput(): '''First line contains two arguments n = number of vertices m = number of edges in the graph next m line conatins (a,b) reresenting an edge.''' n, m = map(int, raw_input().split(" ")) edges = [] for i in range(0, m): a, b = map(int, raw_input().split(" ")) edges.append((a, b)) graph = Graph(n, m, edges) print graph.toString()
def _graph_factory(self): graph = Graph(container_dict=dict(padding=5, bgcolor='lightgray')) graph.new_plot( padding=[50, 5, 5, 50], # title='{}'.format(self.title), xtitle='CDD Operating Voltage (V)', ytitle='Intensity (fA)', ) graph.new_series(type='scatter', marker='pixel') return graph
def test_two_disjoint_edges(concomp): msg = "{} failed".format(concomp.__name__) g = Graph() g.add_edge(0, 1) g.add_edge(2, 3) cc = concomp(g) assert len(cc) == 4 assert cc[0] == cc[1] assert cc[2] == cc[3] assert cc[0] != cc[2]
def _graph_factory(self): g = Graph(window_title='Coincidence Scan', container_dict=dict(padding=5, bgcolor='lightgray') ) g.new_plot(padding=[50, 5, 5, 50], ytitle='Intensity (fA)', xtitle='Operating Voltage (V)') for di in self.spectrometer.detectors: g.new_series( name=di.name, color=di.color) return g
def testExtendSubgraph1(): graph = Graph(5, 5, [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]) extender = ExtendSubgraph(graph, 101, 3) task = Task([0, 1, 1, 0, 0], [0, 3], 0, 0) newTasks = extender.generateNewTasks(task) for task in newTasks: print task.vertices, task.edges
def generate_unbalanced_graph(self, nodes_in_cluster): nodes = [] for i in range(0, self.clusters): nodes.extend([i] * nodes_in_cluster[i]) random.shuffle(nodes) edges = np.zeros((self.n, self.n)) random_pin = np.random.choice([0, 1], edges.shape, p=[1 - self.p_in, self.p_in]) random_pout = np.random.choice([0, 1], edges.shape, p=[1 - self.p_out, self.p_out]) for i in range(0, self.n): for j in range(0, self.n): is_same_cluster = nodes[i] == nodes[j] if is_same_cluster: edges[i][j] = random_pin[i][j] else: edges[i][j] = random_pout[i][j] return Graph(self.n, nodes, edges)
def test_simple_chain(concomp, n): assert n > 1 msg = "{} failed".format(concomp.__name__) g = Graph() for i in range(n): g.add_edge(i, i + 1) cc = concomp(g) assert len(cc) == n + 1 for i in range(n): assert cc[i] == cc[i + 1], msg
def testExtendSubgraph3(): graph = Graph(3, 3, [(0, 1), (1, 2), (0, 2)]) extender = ExtendSubgraph(graph, 101, 3) task = Task([1, 1, 1], [1], 0, 0) newTasks = extender.generateNewTasks(task) for task in newTasks: print task.vertices, task.edges
def _graph_factory(self): gc = self.graph_cnt cnt = '' if not gc else gc self.graph_cnt += 1 name = self.parent.name if self.parent else 'Foo' g = Graph(window_title='{} Power Calibration {}'.format(name, cnt), container_dict=dict(padding=5), window_x=500 + gc * 25, window_y=25 + gc * 25 ) g.new_plot( xtitle='Setpoint (%)', ytitle='Measured Power (W)') g.new_series() return g
def test_two_nonterm(algo): test_data_path = LOCAL_CFPQ_DATA.joinpath('two_nonterm') base_algo: BaseProblem = algo() graph = Graph.from_txt(test_data_path.joinpath('Graphs/graph_1.txt')) grammar = cfg_from_txt(test_data_path.joinpath('Grammars/g.cfg')) base_algo.prepare(graph, grammar) result: ResultAlgo = base_algo.solve() assert result.matrix_S.nvals == 156
def __init__(self, graph: Graph): self._n_vars: dict = {} self._e_vars: dict = {} self._k_var: IntVar self._model = cp_model.CpModel() self._graph: Graph = graph if graph.is_empty(): return self._setup_problem()
def benchmark_cyclic_graph(n: int): print() print('graph vertex count = ' + str(n)) graph = Graph.generate_cyclic(n) time_start = time.time() VmtlProblem(graph).get_solution() print('time: ' + str(round(time.time() - time_start, 3)) + 's') print('time: ' + str(round(time.time() - time_start, 5) * 1000) + 'ms')
def _graph_default(self): g = Graph(container_dict=dict(padding=5)) g.new_plot(padding=5) g.set_axis_traits(axis='y', visible=False) g.set_axis_traits(axis='x', visible=False) g.set_grid_traits(grid='x', visible=False) g.set_grid_traits(grid='y', visible=False) return g
def test_two_nonterm(algo): test_data_path = LOCAL_CFPQ_DATA.joinpath('two_nonterm') ms_algo: MultipleSourceProblem = algo() graph = Graph.from_txt(test_data_path.joinpath('Graphs/graph_1.txt')) grammar = cfg_from_txt(test_data_path.joinpath('Grammars/g.cfg')) ms_algo.prepare(graph, grammar) result: ResultAlgo result, with_cache = ms_algo.solve([1]) assert result.matrix_S.nvals == 1 and with_cache.nvals == 1
def graph(poly, opoly, line): from src.graph.graph import Graph g = Graph() g.new_plot() for po in (poly, opoly): po = np.array(po) try: xs, ys = po.T except ValueError: xs, ys, _ = po.T xs = np.hstack((xs, xs[0])) ys = np.hstack((ys, ys[0])) g.new_series(xs, ys) # for i, (p1, p2) in enumerate(lines): # xi, yi = (p1[0], p2[0]), (p1[1], p2[1]) # g.new_series(xi, yi, color='black') return g
def test_two_nonterm(algo): test_data_path = LOCAL_CFPQ_DATA.joinpath('two_nonterm') singlepath_algo: SinglePathProblem = algo() graph = Graph.from_txt(test_data_path.joinpath('Graphs/graph_1.txt')) grammar = cfg_from_txt(test_data_path.joinpath('Grammars/g.cfg')) singlepath_algo.prepare(graph, grammar) result: ResultAlgo = singlepath_algo.solve() assert result.matrix_S.nvals == 156 paths = singlepath_algo.getPath(1, 1, "S") assert paths == 2
def benchmark_ms(algo_name, data, result_dir): """ Measurement function for finding paths from set of vertices @param algo_name: concrete implementation of the algorithm @param data: dictionary in format {path to graph: list of paths to grammars} @param result_dir: directory for uploading results of measurement """ header_index = ['graph', 'grammar', 'size_chunk', 'time', 'count_S'] chunk_sizes = [1, 2, 4, 8, 16, 32, 50, 100, 500, 1000, 5000, 10000, None] for graph in data: result_index_file_path = result_dir.joinpath( f'{graph.stem}-{algo_name.__name__}-msindex') append_header = False if not exists(result_index_file_path): append_header = True result_csv = open(result_index_file_path, mode='a', newline='\n') csv_writer_index = csv.writer(result_csv, delimiter=',', quoting=csv.QUOTE_NONNUMERIC, escapechar=' ') if append_header: csv_writer_index.writerow(header_index) if not exists(result_index_file_path): csv_writer_index.writerow(header_index) g = LabelGraph.from_txt(graph) for grammar in data[graph]: algo = algo_name() algo.prepare(Graph.from_txt(graph), cfg_from_txt(grammar)) for chunk_size in chunk_sizes: chunks = [] if chunk_size is None: chunks = g.chunkify(g.matrices_size) else: chunks = g.chunkify(chunk_size) for chunk in tqdm(chunks, desc=f'{graph.stem}-{grammar.stem}'): algo.clear_src( ) # Attention (TODO): remove this line if you want to cache the result ! start = time() res = algo.solve(chunk) finish = time() csv_writer_index.writerow([ graph.stem, grammar.stem, chunk_size, finish - start, res.matrix_S.nvals ])
def test_two_nonterm(algo): test_data_path = LOCAL_CFPQ_DATA.joinpath('two_nonterm') allpath_algo: AllPathsProblem = algo() graph = Graph.from_txt(test_data_path.joinpath('Graphs/graph_1.txt')) grammar = cfg_from_txt(test_data_path.joinpath('Grammars/g.cfg')) allpath_algo.prepare(graph, grammar) result: ResultAlgo = allpath_algo.solve() assert result.matrix_S.nvals == 156 allpath_algo.prepare_for_exctract_paths() paths = allpath_algo.getPaths(1, 1, "S", 3) assert len(paths) == 1
def benchmark_index(algo_name, data, result_dir, rounds): """ Measurement function for finding paths between all pairs of vertices @param algo_name: concrete implementation of the algorithm @param data: dictionary in format {path to graph: list of paths to grammars} @param result_dir: directory for uploading results of measurement @param rounds: number of measurement rounds @return: variance value for each round of measurements """ header_index = ['graph', 'grammar', 'time', 'count_S', 'variance'] variances = [] for graph in data: result_index_file_path = result_dir.joinpath( f'{graph.stem}-{algo_name.__name__}-index') append_header = False if not exists(result_index_file_path): append_header = True result_csv = open(result_index_file_path, mode='a', newline='\n') csv_writer_index = csv.writer(result_csv, delimiter=',', quoting=csv.QUOTE_NONNUMERIC, escapechar=' ') if append_header: csv_writer_index.writerow(header_index) for grammar in data[graph]: algo = algo_name() algo.prepare(Graph.from_txt(graph), cfg_from_txt(grammar)) count_S = 0 times = [] for _ in tqdm(range(rounds), desc=f'{graph.stem}-{grammar.stem}'): algo.prepare_for_solve() start = time() res = algo.solve() finish = time() times.append(finish - start) count_S = res.matrix_S.nvals sample_mean = get_sample_mean(times) variances.append(get_variance(times, sample_mean)) csv_writer_index.writerow([ graph.stem, grammar.stem, sample_mean, count_S, get_variance(times, sample_mean) ]) return variances
def _execute_power_calibration_check(self): ''' ''' g = Graph() g.new_plot() g.new_series() g.new_series(x=[0, 100], y=[0, 100], line_style='dash') do_later(self._open_graph, graph=g) self._stop_signal = TEvent() callback = lambda pi, r: None self._iterate(self.check_parameters, g, False, callback)
def _graph_default(self): g = Graph(container_dict=dict(padding=5, kind='h')) g.new_plot(xtitle='weight (mg)', ytitle='40Ar* (fA)', padding=[60, 20, 60, 60] # padding=60 ) g.new_series() g.new_plot(xtitle='40Ar* (fA)', ytitle='%Error in Age', padding=[30, 30, 60, 60] ) g.new_series() # fp = create_line_plot(([], []), color='red') # left, bottom = add_default_axes(fp) # bottom.visible = False # left.orientation = 'right' # left.axis_line_visible = False # bottom.axis_line_visible = False # left.visible = False # if self.kind == 'weight': # bottom.visible = True # bottom.orientation = 'top' # bottom.title = 'Error (ka)' # bottom.tick_color = 'red' # bottom.tick_label_color = 'red' # bottom.line_color = 'red' # bottom.title_color = 'red' # else: # left.title = 'Weight (mg)' # fp.visible = False # gd = GuideOverlay(fp, value=0.01, orientation='v') # fp.overlays.append(gd) # g.plots[0].add(fp) # self.secondary_plot = fp return g
def _get_k_range(graph: Graph) -> list: vertex_count = len(graph.nodes) edge_count = len(graph.edges) vertex_edge_count = vertex_count + edge_count left_side = VmtlProblem._binomial(vertex_edge_count + 1, 2) + VmtlProblem._binomial( edge_count + 1, 2) right_side = 2 * VmtlProblem._binomial(vertex_edge_count + 1, 2) + VmtlProblem._binomial( vertex_count + 1, 2) max_edges = graph.max_edges( ) # Max amount of edges connected to node in given graph k_min: int = sum(range(1, max_edges + 1)) k_max: int = (max_edges + 1) * vertex_edge_count - k_min return [ i for i in range(k_min, k_max + 1) if left_side <= i * vertex_count <= right_side ]
def benchmark_single_path(algo_name, data, result_dir): """ Measurement function for extract single path @param algo_name: concrete implementation of the algorithm @param data: dictionary in format {path to graph: list of paths to grammars} @param result_dir: directory for uploading results of measurement """ header_paths = ['graph', 'grammar', 'len_path', 'time'] for graph in data: result_paths_file_path = result_dir.joinpath( f'{graph.stem}-{algo_name.__name__}-singlepaths') append_header = False if not exists(result_paths_file_path): append_header = True result_csv = open(result_paths_file_path, mode='a', newline='\n') csv_writer_paths = csv.writer(result_csv, delimiter=',', quoting=csv.QUOTE_NONNUMERIC, escapechar=' ') if append_header: csv_writer_paths.writerow(header_paths) if not exists(result_paths_file_path): csv_writer_paths.writerow(header_paths) for grammar in data[graph]: algo = algo_name() algo.prepare(Graph.from_txt(graph), cfg_from_txt(grammar)) res = algo.solve() for elem in tqdm(res.matrix_S, desc=f'{graph.stem}-{grammar}-paths'): start = time() paths = algo.getPath(elem[0], elem[1], "S") finish = time() csv_writer_paths.writerow( [graph.stem, grammar.stem, paths, finish - start])
def _finish_calibration(self): super(FusionsCO2PowerCalibrationManager, self)._finish_calibration() g = Graph() g.new_plot() # plot W vs 8bit dac x = self.graph.get_data(axis=1) _, y = self.graph.get_aux_data() xf = self.graph.get_data(axis=1, series=2) _, yf = self.graph.get_aux_data(series=3) # print xf # print yf x, y = zip(*zip(x, y)) xf, yf = zip(*zip(xf, yf)) g.new_series(x, y) g.new_series(xf, yf) self._ipm_coeffs_w_v_r = self._regress(x, y, FITDEGREES['linear']) self. _ipm_coeffs_w_v_r1 = self._regress(xf, yf, FITDEGREES['linear']) self._open_graph(graph=g)
def _gc(self, p, det, kind): g = Graph(container_dict=dict(padding=5), window_width=1000, window_height=800, window_x=40, window_y=20 ) with open(p, 'r') as fp: # gather data reader = csv.reader(fp) header = reader.next() groups = self._parse_data(reader) ''' groups= [data,] data shape = nrow,ncols ''' data = groups[0] x = data[0] y = data[header.index(det)] sy = smooth(y, window_len=120) # , window='flat') x = x[::50] y = y[::50] sy = sy[::50] # smooth # plot g.new_plot(zoom=True, xtitle='Time (s)', ytitle='{} Baseline Intensity (fA)'.format(det)) g.new_series(x, y, type=kind, marker='dot', marker_size=2) g.new_series(x, sy, line_width=2) # g.set_x_limits(500, 500 + 60 * 30) # g.edit_traits() return g
def setup(self): self.g = Graph()
class Controller(ControllerBase): __view = None __file_view = None __database_view = None __graph_view = None __current_list = [] __serial_file = None __query_creator = None __EMPID = 0 def __init__(self, view): self.__view = view self.__file_view = FileReader() self.__database_view = DatabaseView() self.__graph_view = Graph() self.__query_creator = QueryCreator() self.__logger = Logger() with open('src\config.json') as json_data_file: data = json.load(json_data_file) self.__serial_file = data['pickle']['file'] self.__database_name = data['mysql']['db'] def load_file(self, path): data = self.__file_view.get_file_data(path) if data == FileNotFoundError: self.__view.output(data) else: self.__validate_contents(data) def __validate_contents(self, content): employee = Employee() self.__current_list = [] for i, x in enumerate(content): result = employee.add_list(x) if 'fields' in result: self.__current_list.append(result['fields']) else: x = result['tags'] self.__view.output('{} {}'.format(i, ' '.join(x))) def __to_lists(self, list_of_employees): self.__current_list = [] for emp in list_of_employees: self.__current_list.append(emp.to_list()) def pickle(self, args): if len(args) > 1: self.__view.output("Too many parameters") elif len(self.__current_list) == 0: self.__view.output("No data to pickle") elif len(args) == 1: Serial.pickle_this(args[0], self.__current_list) else: print('x') Serial.pickle_this(self.__serial_file, self.__current_list) self.__current_list = [] def unpickle(self, args): """ Gets the data previously stored in a pickle. Places this in __current_list :args: overwrite or append """ if len(args) > 1: self.__view.output('Unpickle accepts one argument [overwrite or append]') return elif len(args) == 1: self.__current_list = Serial.unpickle_this(args[0]) else: self.__current_list = Serial.unpickle_this(self.__serial_file) def display(self, args): if len(args) > 0: self.__view.output('display accepts no parameters') elif len(self.__current_list) > 0: for row in self.__current_list: self.__view.output(row) else: self.__view.output('No data to display') def save_to_database(self, args): if len(args) > 0: self.__view.output('display accepts no parameters') elif self.__current_list is []: self.__view.output('No data to save') else: self.__database_view.save_data_to_new(self.__database_name, self.__current_list) def chart_pie(self, title, data, label=None): sql = '' if label is not None: sql = self.__query_creator.get_pie_data_sum(data, label) else: sql = self.__query_creator.get_pie_data_count(data) new_list = self.__get_chart_data(sql) data_x = 1 # list numbers label_x = 0 self.__graph_view.plot_pie(title, new_list[label_x], new_list[data_x]) def chart_bar(self, title, x, y, top): sql = self.__query_creator.get_bar_data(x, y, top) new_list = self.__get_chart_data(sql) x_pos = 0 y_pos = 1 self.__graph_view.plot_bar(title, x, y, new_list[x_pos], new_list[y_pos]) def __get_chart_data(self, sql): from_db = self.__database_view.get_input(self.__database_name, sql) return self.__fix_list(from_db) @staticmethod def __fix_list(from_db): print(from_db) new_list = [[], []] for i in from_db: new_list[0].append(i[0]) new_list[1].append(i[1]) return new_list
import re from pathlib import Path from flask import Flask, render_template, send_from_directory, request, Response, flash, redirect, url_for from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.wsgi import WSGIContainer from src.graph.graph import Graph from src.graph.vmtl_problem import VmtlProblem app = Flask(__name__) app.secret_key = b'blablabla' app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 graph = Graph() Path("data").mkdir(parents=True, exist_ok=True) graph_file_path: str = 'data/graph.json' def dir_last_updated(folder): return str(max(os.path.getmtime(os.path.join(root_path, f)) for root_path, dirs, files in os.walk(folder) for f in files)) @app.route("/") def backend_index(): global graph, graph_file_path graph.save_as_json(graph_file_path, id_as_label=True)
def backend_clear_graph(): global graph, graph_file_path graph = Graph() graph.save_as_json(graph_file_path) return render_template("backend-graph-editor.html", last_updated=dir_last_updated('data'))
def frontend_clear_graph(): global graph graph = Graph() return Response(status=200)
def testInitalTaskGeneration1(): graph = Graph(5, 5, [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]) initalTasks = genInitalTasks(graph, 101, 5) for task in initalTasks: print task.vertices, task.edges
poly = np.array(poly) poly *= 1000 # xs, ys = poly.T # cx, cy = xs.mean(), ys.mean() # poly = rotate_poly(poly.T, 45, loc=(cx, cy)) # poly = poly.T use_convex_hull = False npoints, lens = raster(poly, step=750, offset= -500, use_convex_hull=use_convex_hull, find_min=True) from src.graph.graph import Graph g = Graph(window_height=700) g.plotcontainer.padding = 5 g.new_plot(padding=[60, 30, 30, 50], bounds=[400, 400], resizable='h', xtitle='X (microns)', ytitle='Y (microns)') if use_convex_hull: poly = convex_hull(poly) xs, ys = poly.T cx, cy = xs.mean(), ys.mean() P = poly.T xs = np.hstack((xs, xs[0])) ys = np.hstack((ys, ys[0])) else:
from src.graph.graph import Graph from src.graph.graph import stringToGraph assert stringToGraph("3$011101110").toString()\ == Graph(3,3,[(0,1),(1,2),(0,2)]).toString()
def _calculate_mean_ratio(self, s40, s36): r = [i40 / i36 for i40, i36 in zip(s40, s36)] v = [vi.nominal_value for vi in r] errs = [vi.std_dev for vi in r] m, e = calculate_weighted_mean(v, errs) return m, e if __name__ == '__main__': from numpy import linspace, polyfit, polyval d = DeadTime() g = Graph() g.new_plot(padding=[30, 10, 20, 40]) g.new_plot(padding=[30, 10, 20, 40], show_legend=True) nshots = d.read_csv() # taus = range(5, 40, 5) taus = linspace(0, 30, 41) rratios1 = [] mswds1 = [] for i in KEYS: s40 = nshots[i + '40'] s36 = nshots[i + '36'] m1, _ = d._calculate_mean_ratio(s40, s36) print 'uncorrected ratio {} = {:0.2f} '.format(i, m1)
from src.problems.Base.algo.matrix_base.matrix_base import MatrixBaseAlgo from src.problems.MultipleSource.algo.matrix_ms.matrix_ms import MatrixMSBruteAlgo, MatrixMSOptAlgo from src.problems.MultipleSource.algo.tensor_ms.tensor_ms import TensorMSAlgo from src.problems.AllPaths.algo.tensor.tensor import TensorSimpleAlgo, TensorDynamicAlgo from src.problems.SinglePath.algo.matrix_single_path.matrix_single_path_index import MatrixSingleAlgo from src.graph.graph import Graph from cfpq_data import cfg_from_txt from src.problems.utils import ResultAlgo from pathlib import Path CASE = Path("test/data/binary_tree/") graph = Graph.from_txt(CASE.joinpath("Graphs/graph_1.txt")) grammar = cfg_from_txt(CASE.joinpath("Grammars/g.cfg")) algo = MatrixBaseAlgo() algo.prepare(graph, grammar) res: ResultAlgo = algo.solve() print(f'MatrixBaseAlgo: {res.matrix_S.nvals}') graph = Graph.from_txt(CASE.joinpath("Graphs/graph_1.txt")) grammar = cfg_from_txt(CASE.joinpath("Grammars/g.cfg")) algo = TensorSimpleAlgo() algo.prepare(graph, grammar) res: ResultAlgo = algo.solve() print(f'TensorSimpleAlgo: {res.matrix_S.nvals}') graph = Graph.from_txt(CASE.joinpath("Graphs/graph_1.txt")) grammar = cfg_from_txt(CASE.joinpath("Grammars/g.cfg"))
class TestGraph: def setup(self): self.g = Graph() def test_add_edge(self): self.g.add_edge(0, 1) for i in range(2): assert len(self.g[i]) == 1, len(self.g[i]) def test_add_edge_loop(self): for i in range(10): self.g.add_edge(i, i + 1) for i in range(1, 9): assert len(self.g[i]) == 2, len(self.g[i]) for i in [0, 10]: assert len(self.g[i]) == 1, len(self.g[i]) def test_del_edge(self): self.g.add_edge(0, 1) for i in [0, 1]: assert len(self.g[i]) == 1, len(self.g[i]) self.g.del_edge(0, 1) for i in [0, 1]: assert len(self.g[i]) == 0, len(self.g[i]) def test_del_edge_nonexistent(self): self.g.del_edge(0, 1) assert True def test_del_edge_multiple(self): for i in range(3): self.g.add_edge(0, 1) self.g.del_edge(0, 1) for i in range(2): assert len(self.g[i]) == 0, len(self.g[i])
def _graph_default(self): g = Graph(container_dict=dict(padding=5, stack_order='top_to_bottom')) g.width = self.record.item_width * 0.73 return g
from config.servers import servers from config.networkParams import MESSAGE_DELIMITER import src.util.network as network def readInput(): '''First line contains two arguments n = number of vertices m = number of edges in the graph next m line conatins (a,b) reresenting an edge.''' n, m = map(int, raw_input().split(" ")) edges = [] for i in range(0, m): a, b = map(int, raw_input().split(" ")) edges.append((a, b)) return n, m, edges def findMasterIpPort(): for s in servers : if s.role == 'master': return s.IP, s.port #master not found assert False if __name__ == '__main__': n, m, edges = readInput() graph = Graph(n, m, edges) MasterIP, MasterPort = findMasterIpPort() network.sendToIP(MasterIP, MasterPort, "INPUT____________" + MESSAGE_DELIMITER + graph.toString()) # TODO Wait for computation to end # merge all output file if required
def _graph_factory(self, with_image=False): g = Graph( container_dict=dict( padding=0 )) g.new_plot( bounds=[250, 250], resizable='', padding=[30, 0, 0, 30]) cx = self.cx cy = self.cy cbx = self.xbounds cby = self.ybounds tr = self.target_radius # if with_image: # px = self.pxpermm #px is in mm # cbx, cby = self._get_crop_bounds() # #g.set_axis_traits(tick_label_formatter=lambda x: '{:0.2f}'.format((x - w / 2) / px)) # #g.set_axis_traits(tick_label_formatter=lambda x: '{:0.2f}'.format((x - h / 2) / px), axis='y') # # bx, by = g.plots[0].bounds # g.plots[0].x_axis.mapper = LinearMapper(high_pos=bx, # range=DataRange1D(low_setting=self.xbounds[0], # high_setting=self.xbounds[1])) # g.plots[0].y_axis.mapper = LinearMapper(high_pos=by, # range=DataRange1D(low_setting=self.ybounds[0], # high_setting=self.ybounds[1])) # cx += self.image_width / 2 # cy += self.image_height / 2 # tr *= px g.set_x_limits(*cbx) g.set_y_limits(*cby) lp, _plot = g.new_series() t = TargetOverlay(component=lp, cx=cx, cy=cy, target_radius=tr) lp.overlays.append(t) overlap_overlay = OverlapOverlay(component=lp, visible=self.show_overlap ) lp.overlays.append(overlap_overlay) g.new_series(type='scatter', marker='circle') g.new_series(type='line', color='red') return g
def main(): graph: Graph = Graph.load_from_json() print(graph)
def testInitalTaskGeneration2(): graph = Graph(3, 3, [(0, 1), (1, 2), (0, 2)]) initalTasks = genInitalTasks(graph, 101, 5) for task in initalTasks: print task.vertices, task.edges