def runImpl(params, standard = True, threadCount = 1, gpu = False, graphFileName=None):
if graphFileName is None:
nnode, nedge, seed = params
graphFileName = graphName(nnode, nedge, seed)
if not os.path.exists(graphFileName):
# generate graph
sys.stderr.write("Generating graph: %s \n" % str(graphFileName))
generate_graph(nnode, nedge, seed)
pname = cacheDir + "/" + regressionName(params, standard)
else:
pname = cacheDir + "/" + regressionName(params, standard, graphFileName=graphFileName)
cmd = regressionCommand(graphFileName, standard, threadCount, gpu)
cmdLine = " ".join(cmd)
try:
outFile = open(pname, 'w')
except Exception as e:
sys.stderr.write("Couldn't open file '%s' to write. %s\n" % (pname, e))
return False
try:
sys.stderr.write("[" + datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f") + "] " + "Executing " + cmdLine + " > " + regressionName(params, standard, graphFileName=graphFileName) + "\n")
graphProcess = subprocess.Popen(cmd, stdout = outFile)
graphProcess.wait()
outFile.close()
except Exception as e:
sys.stderr.write("Couldn't execute " + cmdLine + " > " + regressionName(params, standard, graphFileName=graphFileName) + " " + str(e) + "\n")
outFile.close()
return False
return True
def ParseMessage(msg_obj):
command = msg_obj['command']
output = ""
# Deal with changes in settings before everything else in case they effect monitor
if (command == 'S'):
setting = msg_obj['trigger_id'][2:]
if (setting == "convertTemp"):
monitor.fahrenheit = not monitor.fahrenheit
if (monitor.fahrenheit):
output = "Fahrenheit"
else:
output = "Celsius"
monitor.read_sensor_data()
if (command == 'I'):
try:
sensor_number = msg_obj['trigger_id'][-3]
sensor_data = monitor.get_last_sensor_data(int(sensor_number))
output = formatOutput(sensor_data)
except:
print("Nothing")
elif (command == 'C'):
# This is where we will get the last 10 measurments for each sensor
data_list = {}
for sensor_number in monitor.all_sensor_data.keys():
data_list[sensor_number] = []
j = -1
for i in range(10):
data_list[sensor_number].append(
formatOutput(
monitor.get_specific_sensor_data_records(
sensor_number, j)))
j -= 1
output = data_list
elif (command == 'G'):
last_10 = monitor.get_last_10()
if monitor.fahrenheit:
units = '(F)'
else:
units = '(C)'
generate_graph(last_10, units)
return output
def test_generate_gc_duration_csv(self):
expected_file = self.path + "expected_duration.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None,
graph.GC_DURATION,
result,
self.csv_writer,
False,
self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
def test_generate_memory_csv(self):
expected_file = self.path + "expected_mem.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None,
graph.YG_GC_MEMORY,
result,
self.csv_writer,
False,
self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
def test_generate_gc_reclaimed_csv(self):
expected_file = self.path + "expected_reclaimed.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None,
graph.MEMORY_RECLAIMED,
result,
self.csv_writer,
False,
self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
def send_stock_graph(self, bot, update, args):
symbol = ''.join(args)
print('Requested graph: {}'.format(symbol))
try:
stock = Stock(symbol)
generate_graph(bot, update.message.chat_id,
stock.get_historical_data(), symbol.upper())
print('Graph sent successfully.')
except Exception as e:
self.send_message(bot, update, 'error')
print('Error occured retrieving data:{}'.format(symbol))
def graph():
query = request.args.get('q', None)
_render = request.args.get('render', 'True')
_render = False if _render == 'False' else True
logger.debug('QUERY: ' + query)
start_timer = datetime.now()
if query is not None and _render:
start, end, expressions, data_frame = parse_query(query)
if expressions[0].name == 'metric':
chart = generate_graph(query, start, end, data_frame)
table = ''
elif expressions[0].name == 'log':
chart = '{}'
table = generate_table(start, end, data_frame)
else:
logger.error("Unknown expression type: %s" % str(type(expressions[0])))
chart = '{}'
table = ''
else:
chart = "{}"
table = ''
# query = ''
end_timer = datetime.now()
logger.debug('Took %0.02fs to process this request' % (end_timer-start_timer).total_seconds())
return render('graph.html', 'Graph', chart=chart, table=table, q=query)
async def startup(app: web.Application):
with open('RS_ViaOW.xml', 'r') as file:
all_itinerary_viaow = parse_data(file)
with open('RS_Via-3.xml', 'r') as file:
all_itinerary_via3 = parse_data(file)
all_itinerary = all_itinerary_via3 + all_itinerary_viaow
app['graph'] = generate_graph(all_itinerary)
def main(file):
lines = [x.strip(" \n").strip(';') for x in open(file).readlines()]
triplets = detect_triplets(lines)
triplets_dict = collect_objects_and_rels(triplets)
node_shapes = detect_node_shapes(lines)
return generate_graph(node_shapes, triplets_dict)
def main():
args = build_parser().parse_args()
with open(args.data_path) as file:
data = file.read().splitlines()
graph = generate_graph(data)
workers_working = []
total_time = 0
task_order = ''
while graph.num_free() or workers_working:
while len(workers_working) < args.num_workers and graph.num_free():
task = graph.next_free()
workers_working.append(WorkingWorker(task))
max_time_jump = min(workers_working, key=lambda x: x.time_remaining).time_remaining
total_time += max_time_jump
for worker in workers_working:
worker.time_remaining = worker.time_remaining - max_time_jump
if worker.time_remaining == 0:
graph.remove_deps(worker.task)
task_order += worker.task
workers_working = [worker for worker in workers_working if worker.time_remaining > 0]
print(task_order)
print(total_time)
def save_file(b):
try:
fichier = filedialog.asksaveasfilename(
filetypes=[("Portable Network Graphics",
"*.png"), ("Encapsulated Postcript", "*.eps"),
("Portable Document Format",
"*.pdf"), ("Scalable Vector Graphics", "*.svg,*,svgz"),
("Joint Photographic Experts Group",
"*.jpeg,*.jpg"), (
"PGF code for LaTeX",
"*.pgf"), ("Raw RGBA bitmap",
"*.raw,*.rgba"), ("Postscript",
"*.ps")])
except FileNotFoundError:
messagebox.showerror(
"error", "Problem with file path, the image has not been saved")
return
#Si l'utilisateur a sélecxtionné un chemin
if fichier != "":
dimension = read_files()
if dimension < 1:
return
graphique = generate_graph(dimension, fichier, b)
if graphique != True:
messagebox.showerror("Error", "Can not display the graphic")
def test_grasp():
_, graph = generate_graph(100, 0.5)
solution = grasp(graph, use_path_relinking=False)
print(solution.colors_count, solution.node_order)
solution = grasp(graph, use_path_relinking=True)
print(solution.colors_count, solution.node_order)
def main_func():
while 1:
def check_t(maska):
st = maska[0][0]
kon = maska[0][1]
# print(st, kon)
f = 0
for i in range(len(maska)):
if i == 0:
continue
for j in range(len(maska)):
if kon == maska[j][0]:
kon = maska[j][1]
# print(kon)
break
if kon == st and i < len(maska) - 1:
f = 1
break
if f == 1:
return False
nt += 1
else:
return True
matrix, n = graph.generate_graph()
matrix_c = copy.deepcopy(matrix)
"""
print(n)
for j in range(n):
for q in range(n):
print(matrix[j][q], " ", end="")
print()
"""
le_road_alg, maska = MinRoadAlg.StartProc(matrix, n)
for i in range(len(maska)):
maska[i] = maska[i][0]
if check_t(maska):
break
le_road_perebor, us_town = perebor.mainus(matrix_c, n)
le_road_figny = figny.formicaio_main(matrix_c, n, [3.6, 3.8, 0.5, 1.0])
print(n, le_road_perebor, le_road_alg, le_road_figny)
def main():
args = build_parser().parse_args()
with open(args.data_path) as file:
data = file.read().splitlines()
graph = generate_graph(data)
task_order = ''
while graph.num_free() > 0:
task = graph.next_free()
graph.remove_deps(task)
task_order += task
print(task_order)
def log_environment():
with app.app_context():
db = get_db()
environment = environment_stats()
if environment['temperature'] is None or environment[
'humidity'] is None:
return None
db.execute(
"INSERT INTO environment (env_timestamp, temperature, humidity) VALUES (?, ?, ?)",
(environment['time'], environment['temperature'],
environment['humidity']),
)
db.commit()
# Generate weekly, daily, 6-hour, and 30min graphs graphs
generate_graph(db_con=db,
time_deltas=[(datetime.now() - timedelta(minutes=30)),
(datetime.now() - timedelta(hours=6)),
(datetime.now() - timedelta(days=1)),
(datetime.now() - timedelta(days=7))])
def apc_graph(scoop=""):
def which_item(bin):
return "Item-" + bin
def drop(bin, type):
if bin in scoop and type != "scoop":
return True
return False
return generate_graph(
"ABCDEFGHIJKL",
["grab-empty", "grab-wrong-scoop", "grab-right-scoop", "scoop"],
"BEHK",
which_item,
drop,
)
def main_func(Qu):
rezult = {}
for i in range(Qu):
print(i)
matrix, n = graph.generate_graph()
time_ = time.time()
len_, road = perebor.mainus(matrix, n)
time_ = time.time() - time_
rezult = [matrix, n, len_, time_]
f = open('graph_with_len.txt', 'ta', encoding="utf-8")
print(rezult[1], rezult[2], rezult[3], file=f)
for j in range(rezult[1]):
for l in range(rezult[1]):
print(rezult[0][j][l], end=" ", file=f)
print(file=f)
print(file=f)
f.close()
return rezult
def affichage_fichier():
dimension = read_files()
if dimension < 1:
return
graphique = generate_graph(dimension)
try:
i = 0
with open("sys/window.reso", "r") as f:
for line in f.readlines():
donnees = line.split()
donnees[0] = int(donnees[0])
if i == 0:
h = donnees[0]
else:
l = donnees[0]
i = i + 1
except FileNotFoundError:
messagebox.showerror("Error", "Can not find windows.reso file")
return
if graphique == True:
can_plot.delete(ALL)
graph_origin = PIL.Image.open('data/graphic_brut.png')
graph_reduit = graph_origin.resize((h, l))
img = PIL.ImageTk.PhotoImage(graph_reduit)
dic['image'] = img
item = can_plot.create_image(h / 2, l / 2, image=img)
# mon_image=PhotoImage(file=r"smiley.gif")
# dic['image']= mon_image
# img=can_plot.create_image(250,250,image=mon_image)
fenetre.update_idletasks()
fenetre.update()
menubar.entryconfigure(2, state=NORMAL)
else:
messagebox.showerror("Error", "Can not display the graphic")
################################################################################################### # # # ways of passing arguments # # 1. by list # # x=[1,2,3,4,5] # # y=[1,2,3,3,3] # # generate_graph(x,y) # # # # 2. by tuples [ (x1,y1) , (x2,y2) , (x3,y3) .... , (x10,y10)] # # data=[(1,1),(2,2),(3,3),(4,3),(5,3)] this will generate graph as same as above # # generate_graph(*data) # # # # # ################################################################################################### from graph import generate_graph # FOR FUN =>> uncomment below and RUN. #smile=[(1, 4),(1, 6),(2, 4),(2, 6),(3, 4),(3, 6),(1, 5),(3, 5),(6, 4),(6, 6),(7, 4),(7, 6),(8, 4),(8, 6),(6, 5),(8, 5),(2,2),(3,1),(4,1),(5,1),(6,1),(7,2)] #generate_graph(*smile) x = [1, 2, 3, 4, 5, 6, 7] y = [1, 2, 3, 4, 3, 2, 1] generate_graph(x, y)
from pyhard2.driver.digitek import DT80k
from pyhard2.driver.fluke import Fluke18x
from pyhard2.driver.ieee.scpi import ScpiPowerSupply, ScpiDCVoltmeter
from pyhard2.driver.keithley import Model6487
from pyhard2.driver.peaktech import Pt1885
from pyhard2.driver.pfeiffer import Maxigauge
from pyhard2.driver.virtual import VirtualInstrument
from pyhard2.driver.watlow import Series988
from graph import generate_graph
for driver_type in (Ngc2d,
CS400,
Controller,
Daq,
Sm700Series,
DT80k,
Fluke18x,
ScpiPowerSupply,
ScpiDCVoltmeter,
Model6487,
Pt1885,
Maxigauge,
VirtualInstrument,
Series988):
driver = driver_type(drv.TesterSocket())
name = driver.__class__.__name__
generate_graph(name, driver, os.path.join("documentation", "gv",
".".join((name, "txt"))))
def presentation(function_arguments, function_values, polynomial_values, function_number, interpolation_arguments,
interpolation_values):
generate_graph(function_arguments, function_values, polynomial_values, function_number, interpolation_arguments,
interpolation_values)
def StartProc():
import graph
import copy
matrix, n = graph.generate_graph() # Подключение графа
"""
matrix = [[-2, 20, 18, 12, 8], [5, -2, 14, 7, 11], [12, 18, -2, 6, 11], [11, 17, 11, -2, 12], [5, 5, 5, 5, -2]]
n = 5
"""
matrix_is = copy.deepcopy(matrix)
le_road = 0
def main_func(matrix, matrix_is, n, le_road):
s = 0
for i in range(n):
for j in range(n):
s += matrix[i][j]
if s == (-2 * n * n):
return le_road, matrix
def red_str(matrix, n):
str_mas_min = [] # Массив с минимальными значениями в строке
for i in range(n): # Нахождение минимального числа
min_zn = 1000
for j in range(n):
if matrix[i][j] == -2:
continue
if matrix[i][j] < min_zn:
min_zn = matrix[i][j]
str_mas_min.append(min_zn)
for i in range(n): # Отнимаем минимальное число из строки
for j in range(n):
if matrix[i][j] == -2:
continue
matrix[i][j] -= str_mas_min[i]
return matrix
matrix = copy.deepcopy(red_str(matrix, n))
def red_stl(matrix, n):
stl_mas_min = [] # Массив с минисальным значением в столбце
for i in range(n): # Нахождения мимума в столбце
min_zn = 1000
for j in range(n):
if matrix[j][i] == -2:
continue
if min_zn > matrix[j][i]:
min_zn = matrix[j][i]
stl_mas_min.append(min_zn)
for i in range(n): # Редукция по столбам(отнимаем минимум)
for j in range(n):
if matrix[j][i] == -2:
continue
matrix[j][i] -= stl_mas_min[i]
return matrix
matrix = copy.deepcopy(red_stl(matrix, n))
def red_tab(matrix, n):
matrix_s = [] # Таблица с коэфицентами для ноля
for i in range(n): # Вычиселния коэфицента
matrix_s.append([])
for j in range(n):
if matrix[i][j] == 0:
min_str = 10000
min_stl = 10000
for h in range(n):
if h == j:
continue
if matrix[i][h] == -2:
continue
if matrix[i][h] < min_str:
min_str = matrix[i][h]
for g in range(n):
if g == i:
continue
if matrix[g][j] == -2:
continue
if matrix[g][j] < min_stl:
min_stl = matrix[g][j]
matrix_s[i].append(min_stl + min_str)
else:
matrix_s[i].append(-1)
return matrix, matrix_s
ot = red_tab(matrix, n)
matrix, matrix_s = copy.deepcopy(ot[0]), copy.deepcopy(ot[1])
def find_max_cof(matrix_s):
max_cof = -3
max_cof_kor = []
max_cof_kor.append([])
max_cof_kor[0] = [-1, -1]
for i in range(n):
for j in range(n):
if matrix_s[i][j] == -1:
continue
else:
if matrix_s[i][j] >= max_cof:
max_cof = matrix_s[i][j]
max_cof_kor[0] = [i, j]
for i in range(n):
for j in range(n):
if matrix_s[i][j] == -1:
continue
if i == max_cof_kor[0][0] and j == max_cof_kor[0][1]:
continue
if matrix[i][j] == max_cof:
max_cof_kor.append([i, j])
return max_cof_kor
max_cof_kor = find_max_cof(matrix_s)
min_road = 10000
for q in range(len(max_cof_kor)):
now_road = le_road
matrix_w = copy.deepcopy(matrix)
now_road += matrix_is[max_cof_kor[q][0]][max_cof_kor[q][1]]
for i in range(n):
for j in range(n):
if matrix_w[i][j] == -2:
continue
if i == max_cof_kor[q][0]:
matrix_w[i][j] = -2
if j == max_cof_kor[q][1]:
matrix_w[i][j] = -2
matrix_w[max_cof_kor[q][1]][max_cof_kor[q][0]] = -2
le, matrix_w = main_func(matrix_w, matrix_is, n, now_road)
if le <= min_road:
min_road = le
s = 0
for i in range(n):
for j in range(n):
s += matrix_w[i][j]
if s == (-2 * n * n):
return le, matrix_w
return le_road, matrix
le_road, matrix = main_func(matrix, matrix_is, n, le_road)
return le_road, matrix_is, n
sensorsdata = serial_connection.readline().decode('UTF-8').split('/t')
sensorairmois = float(sensorsdata[0])
sensortemp = float(sensorsdata[1])
sensorsoil = float(str(sensorsdata[2].strip('\r\n')))
sensortime = str(
datetime.datetime.fromtimestamp(int(
time.time())).strftime('%H:%M')) #Current Time
#Database Operations
mysqlcon.connect()
mysqlcon.insert_data(sensortime, sensorairmois, sensorsoil, sensortemp)
mysqlcon.connect()
mysqlcon.update_data(sensortime, sensorairmois, sensorsoil, sensortemp)
#Generate Graph
graph_image = graph.generate_graph()
#Flow control
if (sensorsoil > 30):
print(
str('Everything is fine, Air Moisture is {}% , Soil Moisture is {}% and Temperature is {}C'
).format(sensorairmois, sensorsoil, sensortemp))
time.sleep(15)
elif (sensorsoil <= 30):
print(
str('Need Attention, Air Moisture is {}% , Soil Moisture is {}% and Temperature is {}C'
).format(sensorairmois, sensorsoil, sensortemp))
time.sleep(15)
matrices = []
for i in range(num_nodes):
matrices.append(
np.matrix(
np.random.normal(size=(range_dimension,
decision_variable_size))))
vector = sum([
matrices[i] * np.random.normal(size=(decision_variable_size, 1))
for i in range(num_nodes)
])
# Construct graph
graph = generate_graph(num_nodes, graph_density=graph_density)
# Solve!
primal, dual, primal_history, dual_history = basis_pursuit(
matrices,
vector,
graph,
num_iters=num_steps,
solver_param=solver_param,
gamma=gamma,
non_smooth_one_norm=non_smooth_one_norm,
debug_output=debugging_output)
else:
folder = from_folder
#!/usr/bin/env python
import os
import argparse
import fs
import graph
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("directory", type=str,
help="path to the root directory of project")
return parser.parse_args()
if __name__ == '__main__':
args = parse_args()
directory = os.path.abspath(args.directory)
tree = fs.recursively_generate_directory_tree(directory)
graph.generate_graph(tree)
import numpy as np
from util import measure_algorithm
from bridge_finder import BridgeFinder
from random_search import Random2BridgeFinder
from sys import setrecursionlimit
from sort import radix_sort, bucket_sort
if __name__ == '__main__':
# graph = generate_graph(6, 0.3)
# nx.draw_networkx(graph)
# plt.draw()
# plt.pause(120)
setrecursionlimit(10000)
sizes = list(np.linspace(10, 200, dtype=np.int, num=20))
graphs = [generate_graph(size, p=0.3) for size in sizes]
bf = BridgeFinder()
random_bf_std = Random2BridgeFinder()
random_bf_radix = Random2BridgeFinder(sort=radix_sort)
random_bf_bucket = Random2BridgeFinder(sort=bucket_sort)
time = measure_algorithm(bf, graphs)
plt.plot(sizes, time)
plt.draw()
plt.pause(120)
time = measure_algorithm(random_bf_std, graphs)
plt.plot(sizes, time)
plt.draw()
plt.pause(120)
from graph import generate_graph, weight_nodes, weight_edges, get_probabilities
from greedy import greedy_celf
from enviroment import *
from information_cascade import *
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import tqdm
from LUCB_learner import *
if __name__ == "__main__":
#features = [0.1, 0.08, 0.05, 0.02]
n_features = 4
graph = generate_graph(100, 5, 0.1, 1234)
graph = weight_edges(graph, n_features)
graph = weight_nodes(graph)
budget = 7.5
delta = 0.5
# optimal with greedy_celf#
greedy_N_simulations = 1000
start_time = time.time()
greedy = []
greedy = greedy_celf(graph, budget, delta)
opt_seeds = sorted(greedy[1])
spread_cumulative = []
import graph
matrix, n = graph.generate_graph()
for i in range(n):
print()
for j in range(n):
print(matrix[i][j], " ", end="")
def test_generate_gc_duration_csv(self):
expected_file = self.path + "expected_duration.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None, graph.GC_DURATION, result, self.csv_writer,
False, self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
def test_generate_gc_reclaimed_csv(self):
expected_file = self.path + "expected_reclaimed.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None, graph.MEMORY_RECLAIMED, result,
self.csv_writer, False, self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
def test_generate_memory_csv(self):
expected_file = self.path + "expected_mem.csv"
result = self.parser.parse_file(self.sample_file)
graph.generate_graph(None, graph.YG_GC_MEMORY, result, self.csv_writer,
False, self.result_file)
self.assertTrue(filecmp.cmp(self.result_file, expected_file))
todo_nodes.remove(node)
t += 1
# reset status of nodes of the graph to susceptible
for n in graph.nodes():
graph.nodes[n]['status'] = 'susceptible'
a = [weighted_spread, triggered_nodes]
return a
if __name__ == "__main__":
features = [0.10, 0.08, 0.05, 0.02]
graph = generate_graph(100, 5, 0.05, 123)
graph = weight_edges(graph, features)
graph = weight_nodes(graph)
N_simulations = 100
seed_set = [4, 8, 15, 16, 23, 42]
spread_simulation = []
# for u, v in graph.edges():
# print(u,v)
# for j,k in graph.edges():
# if (u,v) == (k,j):
# print("Oh no")
# break
# a = []
import graph
import copy
matrix, n = graph.generate_graph() # Подключение графа
matrix_is = copy.deepcopy(matrix)
for i in range(n):
print()
for j in range(n):
print(matrix_is[i][j], " ", end="")
print()
matrix_us_town = []
le_road = 0
def main_func(matrix, matrix_is, n, le_road, matrix_us_town):
for q in range(n):
s = 0
for i in range(n):
for j in range(n):
s += matrix[i][j]
if s == (-2 * n):
break
def red_str(matrix, n):
str_mas_min = [] # Массив с минимальными значениями в строке
for i in range(n): # Нахождение минимального числа
def display_from(email_addr):
emails = Message.objects(from_str=email_addr).all()
count = emails.count()
print "%s emails found authored by '%s'" % (count, email_addr)
g = graph.generate_graph(emails)
graph.display_graph(g)
def graph():
dockerfiles = Path(__file__).parent / ".." / "dockerfiles"
generate_graph({ dfile: parse_dockerfile(dockerfiles / dfile) for dfile in listdir(dockerfiles) })
