def main(): mesh_filename = 'meshes/mini-airfoil.p.part' cell2nodes = read_mesh_from_file(mesh_filename, 'cell_to_ord_nodes', int, frozenset) node2node = read_mesh_from_file(mesh_filename, 'node_to_node', int, frozenset) # DEBUGGING global nodes2cell nodes2cell = invert_list(cell2nodes) ## END DEBUGGING # Setup conditions seed(7) start_node = randint(0, len(node2node) - 1) start_node = 58 # Go cell2ord = dict() quad_search = QuadSearch(node2node) for count, c in enumerate(quad_search.visit(start_node, BestFirstSearchCandidates)): # print c cell2ord[c.get_cell_id()] = count def cell_labeller(old_cell, new_cell): if old_cell in cell2ord: return '*%d*' % cell2ord[old_cell] else: return old_cell draw(label_cells=cell_labeller)
def generate_schema(entries, resources): resource_names = nlp.plural_extend(resources) model = {} hateoas_model = {} nlp_model = nlp.resource_analysis(resources, resource_names) model = nlp_model['model'] hateoas_model = nlp_model['graph'] with open('data.txt', 'w') as outfile: json.dump(model, outfile, indent=4) with open('graph.txt', 'w') as outfile: json.dump(hateoas_model, outfile, indent=4) # with open('data.txt') as data_file: # model = json.load(data_file) # with open('graph.txt') as data_file: # hateoas_model = json.load(data_file) graph.draw(hateoas_model) oas_schema = formatter.generate_swagger(model) oas_schema['info'] = {} for entry in entries: field = entry[0] text = entry[1].get() if field in ['title', 'description', 'version']: oas_schema['info'][field] = text elif field in ['basePath', 'host']: oas_schema[field] = text oas_schema['swagger'] = '2.0' oas_schema['schemes'] = ['https'] oas_schema['produces'] = ['application/json'] with open('swagger.json', 'w') as outfile: json.dump(oas_schema, outfile, indent=4) with open('swagger.yaml', 'w') as outfile: yaml.dump(oas_schema, outfile, indent=4)
def _draw_graph(self, title, graph, rect, label_color=white, label_font=textutils.largeFont): # Create title and get remaining space content = layout.make_titled_rect( self.screen, rect, title, label_color, self.background_color, label_font, 8, 4 ) # Draw graph graph.draw(self.screen, content)
def show_index(): img_name = 'graph.png' graph.draw(img_name) env = Environment(loader=FileSystemLoader('./')) template = env.get_template('index.html') return render_template(template, user_image='/file/' + img_name)
def run_graph(self) -> None: '''Grab input from tk.entrys''' is_good, argum = self.validate() if is_good: self.error_var.set('') try: graph.draw(*argum, self.tk_int_var.get(), self.menu.get()) # pylint: disable=no-value-for-parameter except ValueError: self.error_var.set("Function does not exist in range")
def _draw_graph(self, title, graph, rect, label_color=white, label_font=textutils.largeFont): # Create title and get remaining space content = layout.make_titled_rect(self.screen, rect, title, label_color, self.background_color, label_font, 8, 4) # Draw graph graph.draw(self.screen, content)
def update(timer): sphd.clear() t = weather.temperature() p = weather.pressure() # Record if timer % 60 == 0: log(t, p) # Draw if (timer / 10) % 2 == 0 or len(history['temperature']) < 5: s = round(t if (timer / 5) % 2 == 0 else p, 3) typography.write("%s" % s) else: graph.draw(history['temperature' if (timer / 5) % 2 == 0 else 'pressure']) sphd.show() # Trim history history['temperature'] = history['temperature'][-60:] history['pressure'] = history['pressure'][-60:]
def printNetwork(outFile, latestLabel=None): alarmList = getRankedAlarms() name2idx = network['name2idx'] v_prop = network['graph'].vertex_properties['info'] v_color = network['graph'].vertex_properties['color'] v_shape = network['graph'].vertex_properties['shape'] for t, confidence in alarmList: v_shape[name2idx[t]] = 'circle' if t == latestLabel: v_color[name2idx[t]] = 'green' elif t in oracleQueries: v_color[name2idx[t]] = 'red' elif t not in labelledTuples: alpha = getAlpha(confidence) v_color[name2idx[t]] = '#0000FF' + alpha elif not labelledTuples[t]: v_color[name2idx[t]] = 'black' # negative label graph.draw(network['graph'], outFile)
def redrawWindow(self): for graph in self.graphs: graph.draw()
def schedule(conn, tasks, cpus): print(conn, "<< connections") print(tasks, "<< tasks") tasks_list = tasks.copy() levels = split_levels(conn) cp = find_critical_path(conn, tasks) # fixme: iterate and check all pathes print(cp, "<< critical path") plan_task = [[i, [], []] for i, _ in enumerate(tasks)] # (task, cpu, time) plan_copy = [[] for i in range(cpus)] # (task, cpu, time) def data_ready(task): return plan_task[task][2][0] + tasks[task] def get_ready(time): """ List ready tasks (without data transfer)""" ready = list(set([t[0] for t in plan_task if t[1] and (time >= t[2][0] + tasks[t[0]])])) return ready def get_ready_cpus(time): """ List free cpus """ cpus_lst = list(range(1, cpus+1)) for t in plan_task: for i, _ in enumerate(t[1]): if t[2][i] <= time < (t[2][i] + tasks[t[0]]): if t[1][i] in cpus_lst: cpus_lst.remove(t[1][i]) return cpus_lst def get_dependencies(task): return [i for i, v in enumerate(conn[:, task]) if v > 0] def get_calculated(time): ready = get_ready(time) return [t for t in range(len(tasks)) if is_sublist(get_dependencies(t), ready)] def get_ready_to_plan(time): ready = get_calculated(time) return ready def is_planned(task): return any(i[0] == task and i[1] for i in plan_task) def not_planned(tasks): return [int(t) for t in tasks if not is_planned(t)] def get_dependents(task): return [i for i, v in enumerate(conn[task]) if v > 0] def is_busy(time, cpu): return any(any(tx <= time < tx + tasks[t[0]] for tx in t[2]) for t in plan_task if t[1] and cpu in t[1]) def get_execution_frame(from_time, w, cpu): ts = int(from_time) while not all(not is_busy(t, cpu) for t in range(ts, ts+int(w))): # can be better ts += 1 return ts def do_plan_copy(time, weighs, cpu, fake=True, nodups=False): if fake: _plan_task = deepcopy(plan_task) _plan_copy = deepcopy(plan_copy) else: _plan_task = plan_task _plan_copy = plan_copy time_added = [time] plans = [] for d, w in weighs: d_cpu = _plan_task[d][1][0] if d_cpu == cpu: continue time_start = _plan_task[d][2][0] + tasks[d] mc1 = nearest_copy_ability(time_start, cpu, w) mc2 = nearest_copy_ability(time_start, d_cpu, w) plan = max(mc1, mc2) plans.append((d, w, plan, time_start)) for d, w, plan, time_start in sorted(plans, key=lambda x:x[3]): d_cpu = _plan_task[d][1][0] mc1 = nearest_copy_ability(time_start, cpu, w) mc2 = nearest_copy_ability(time_start, d_cpu, w) plan = max(mc1, mc2) while mc1 != mc2: mc1 = nearest_copy_ability(plan, cpu, w) mc2 = nearest_copy_ability(plan, d_cpu, w) plan = max(mc1, mc2) weights_sub = sorted([(d, conn[d, r]) for d in get_dependencies(d)], key=lambda x: x[1], reverse=True) predicted_rerun = do_plan_copy_predict(time, weights_sub, cpu) predicted_rerun = get_execution_frame(predicted_rerun, tasks[d], cpu) # compare if False or (not nodups and predicted_rerun + tasks[d] >= plan + w): _plan_copy[cpu-1].append((plan, plan + w, d+1, r+1)) _plan_copy[d_cpu-1].append((plan, plan + w, d+1, r+1)) time_added.append(plan + w) else: do_plan_copy(time, weights_sub, cpu) _plan_task[d][1].append(cpu) _plan_task[d][2].append(predicted_rerun) time_added.append(predicted_rerun + tasks[d]) _plan_task[r][1].append(cpu) _plan_task[r][2].append(max(time_added)) if not weighs: time_added = [0] return _plan_copy, _plan_task, max(time_added) def do_plan_copy_predict(time, weight, cpu, nodups=False): return do_plan_copy(time, weight, cpu, fake=True, nodups=nodups)[2] def is_busy_with_copying(time, cpu): return any(p[0] <= time < p[1] for p in plan_copy[cpu-1]) def nearest_copy_ability(time, cpu, w): ts = int(time) while not all(not is_busy_with_copying(t, cpu) for t in range(ts, ts+int(w))): # can be better, +1? ts += 1 return ts time = 0 while not_planned(range(len(tasks))): ready_cpus = get_ready_cpus(time) able_to_plan = not_planned(get_ready_to_plan(time)) if not able_to_plan: time += 1 continue for r in able_to_plan: if not ready_cpus: time += 1 break weights = sorted([(d, conn[d, r]) for d in get_dependencies(r)], key=lambda x: x[1], reverse=True) preferred_cpus = [plan_task[i][1][0] for i, w in weights] # sort weights print(r+1, get_dependencies(r), weights, preferred_cpus, ready_cpus) if preferred_cpus: cpu = pop_priorities(ready_cpus, preferred_cpus) else: cpu = ready_cpus.pop() pt = do_plan_copy_predict(time, weights, cpu) if get_execution_frame(time, tasks[r], cpu) > time: continue # predict CPU predicted = [pt] for i in range(int(time), int(pt)+1): _ready_cpus = get_ready_cpus(i) if _ready_cpus: _cpu = pop_priorities(_ready_cpus, preferred_cpus) predicted.append(do_plan_copy_predict(i, weights, _cpu)) if min(predicted) < pt: continue plan_copy, plan_task, _ = do_plan_copy(time, weights, cpu, fake=False) else: time += 1 draw(plan_task, plan_copy, tasks, time+15, cpus, cp)
#!/usr/bin/env python3 # Example: # ./print_bnet.py named_cons_all.txt.cep Alarm.txt GroundTruth.txt output.svg # This program will also generate output.svg.map that contains tha mapping # from vertex numbers to nodes import graph import logging import re import sys import util from graph_tool.all import * cons_file = sys.argv[1] alarm_file = sys.argv[2] ground_truth_file = sys.argv[3] output_file = sys.argv[4] old_alarm_file = sys.argv[5] if len(sys.argv) == 6 else None alarms = util.read_alarm(alarm_file) old_alarms = set() if old_alarm_file is None else util.read_alarm( old_alarm_file) ground_truths = util.read_alarm(ground_truth_file) g = graph.build_graph(cons_file, alarms)['graph'] graph.prepare_visualization(g, alarms, old_alarms, ground_truths) graph.draw(g, output_file) graph.print_node_id(g, output_file + '.map')
def dynamic_page(): return graph.draw()
def dynamics(cls, area, *args): df = cls.areaData(area) graph.draw(df, area, *args)
def plotSoybeanOilData(): soyOilF_df = pullquandl.pullSoybeanOilFutures() soyOilCTR_df = pullquandl.pullSoybeanOilCTR() graph.draw(soyOilF_df, 'Total Long Short Ratio Of Soybean Oil Future since 2006', 'Total Longs/Total Shorts', \ soyOilCTR_df, 'Cumulative Daily Returns For Soybean Oil since 1959', 'Cumulative Daily Returns For Soybean Oil')
import graph as g import netcrawl as nc import dash import dash_core_components as dcc import dash_html_components as html edges = nc.edges() graph = g.net_graph(edges) g.plot(graph) app = dash.Dash() app.layout = html.Div([dcc.Graph(figure=g.draw(graph))]) app.run_server(debug=True)
import graph g = graph.random_graph(6,0.3,directed=True,min_weight=1,max_weight=10) graph.draw(g)
if alt < costToReach[index]: costToReach[index] = alt previousNode[index] = u.index print(f'costs: {costToReach}') print(f'previousNodes: {previousNode}') if __name__ == '__main__': nodes = 10 edges = nodes * 3 g = graph.graph(nodes, edges, weighted=True) k = nodes labels = list(range(1, k//3)) costs = {x:x for x in labels} start = random.randint(0, nodes-1) while sum(g[start]) <= 0: start = random.randint(0, nodes-1) end = start while end == start or sum(g[end]) <= 0: end = random.randint(0, nodes-1) graph.print_matrix(g) print(start, end) algo(g, labels, costs, start, end) graph.draw(g, with_weights=True)
# I love to play around with colors :) accent_color = '#c9c9c9' indicators_color = '#598720' # The use of normalized data is necessary for plotting the price and moving averages in the same graph. data['Close'] = data_n['Close'] data[ci.moving_average_1_label] = data_n[ci.moving_average_1_label] data[ci.moving_average_2_label] = data_n[ci.moving_average_2_label] # data['ATR'] = data_n['ATR'] # data['MACD'] = data_n['MACD'] # data['Stochastics'] = data_n['Stochastics'] # data['RSI'] = data_n['RSI'] # Draw draw(ticker, data[dataset_train_length:], predicted_data, ci, draw_moving_average_1=draw_moving_average_1, draw_moving_average_2=draw_moving_average_2, draw_ATR=draw_ATR, draw_MACD=draw_MACD, draw_Stochastics=draw_Stochastics, draw_RSI=draw_RSI, accent_color=accent_color, indicators_color=indicators_color) show() # save('graph.png')
def run(name, disbale_cache, validate, svalidate, s, draw, fetchall): MODEL = "./model_slim" if fetchall: print("Fetch all descriptions") names = filemanager.lotr_char_names() for name in names: filemanager.getCharacterDescription(name) print("DONE") #print("Train") #status = train.train(training_set) #if status == "OK": # print("DONE") # print("Successfully finished") #else: # print("Error while training") return if s: if name in os.listdir("./data/silver/"): os.remove("./data/silver/" + name) silver = get_silver_family(name) print(silver) return if disbale_cache or name not in os.listdir("./data/family/"): if name in os.listdir("./data/family/"): os.remove("./data/family/" + name) if name in os.listdir("./data/silver/"): os.remove("./data/silver/" + name) family_tree = find_family_relations(to_read=[name], model=MODEL) family = graph.add_relations(family_tree, "./data/family/" + name) else: family = graph.get("./data/family/" + name) print("RUN 1") if validate: silver = get_silver_family(name) #(recall, precision, f1) = _validate(family, silver) #print("recall:", recall) #print("precisision:", precision) #print("F1:", f1) if draw: file1 = "./data/family/" + name file2 = "./data/silver/" + name graph.draw(file1, file2) else: if draw: file1 = "./data/family/" + name graph.draw(file1) if svalidate: family = None family_no_model = None silver = get_silver_family(name) if name not in os.listdir("./data/family/"): family_tree = find_family_relations(to_read=[name], model=MODEL) family = graph.add_relations(family_tree, "./data/family/" + name) else: family = graph.get("./data/family/" + name) if name not in os.listdir("./data/family_no_model/"): family_tree_no_model = find_family_relations( to_read=[name], model="en_core_web_sm") family_no_model = graph.add_relations( family_tree_no_model, "./data/family_no_model/" + name) else: family_no_model = graph.get("./data/family_no_model/" + name) latex_tabell(name, family_no_model, family, silver) print("MAIN DONE")
def main(): args = parse_args() for graph_path in args.graph: graph = nx.read_gpickle(graph_path) draw(graph)
def GodSpeed(): chart = graph.draw(Coin) if (Invested): In(chart) if (not Invested): Out(chart)
def draw_graphs(results_path): graph.draw(results_path)
resources = preprocessor.main(args['folder']) if not resources: print( 'No resources found, did you insert the correct resources folder?') sys.exit() resource_names = nlp.plural_extend(resources) print('Processing resources...') nlp_model = nlp.resource_analysis(resources, resource_names) model = nlp_model['model'] resource_graph = nlp_model['resource_graph'] state_graph = nlp_model['state_graph'] with open('output_files/nlp_model.json', 'w') as outfile: json.dump(nlp_model, outfile, indent=4) print('Generating files...') graph.draw(resource_graph, state_graph, args['fixgraph']) oas_schema = formatter.generate_swagger(model) oas_schema['swagger'] = '2.0' oas_schema['info'] = { "title": oas_settings['INFO']['title'], "description": oas_settings['INFO']['description'], "version": oas_settings['INFO']['version'], "termsOfService": oas_settings['INFO']['termsOfService'], "contact": { 'name': oas_settings['CONTACT']['name'], 'url': oas_settings['CONTACT']['url'], 'email': oas_settings['CONTACT']['email'] }, "license": { 'name': oas_settings['LICENSE']['name'],
def graph_draw(G, output): draw(G, output)
PowerApproximation() ] while True: function_table = mainboilerplate.read_function_table() functions = [] for a in approximations: f = a.find_an_approximation(function_table) if f is not None: functions.append(f) functions.sort(key=lambda x: x.root_mean_square_deviation) results_table = PrettyTable() results_table.field_names = [ "Функция", "Мера отклонения", "Среднеквадратичное отклонение" ] for f in functions: results_table.add_row( [f.text, round(f.s, 3), round(f.root_mean_square_deviation, 3)]) logging.info(results_table) logging.info( "Аппроксимирующая функция с наименьшим среднеквадратическим отклонением: " + functions[0].text) graph.draw(function_table, functions) if input('\nЕще раз? [y/n] ') != 'y': break