def main():
"""
Main function that initializes size for the random data set.
Then calls sortTree and sortQueue by passing generated random dataset as input
function also calculates final time for both operations
these final times are available in different lists which will be given to graph as input
"""
size = 2500
all_lengths = []
tree_time = []
queue_time = []
for i in range(100):
input_list = random_dataset(size)
all_lengths.append(len(input_list))
start_time_tree = current_milli_time()
tree_list = sortTree(input_list)
end_time_tree = current_milli_time()
final_time_tree = end_time_tree - start_time_tree
tree_time.append(final_time_tree)
start_time_queue = current_milli_time()
queue_list = sortQueue(input_list)
end_time_queue = current_milli_time()
final_time_queue = end_time_queue - start_time_queue
queue_time.append(final_time_queue)
print('Dataset sizes : ' + str(all_lengths))
print('Tree time : ' + str(tree_time))
print('Queue time : ' + str(queue_time))
plot(all_lengths, tree_time, queue_time)
def variance_benchmark(args):
cmd_lst = [bin, bin_args, file, func] + args[1:]
print "executing command: %s, please wait..."%(" ".join(cmd_lst))
res_lst_lst = []
for j in range(3):
print "running process at %d time:"%(j)
p = subprocess.Popen(cmd_lst, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
lines = out.split("\n")
res_lst = []
for i in range(len(lines)/2 - 1):
res_lst.append(int(lines[i*2+1]))
res_lst_lst.append(res_lst)
one_time = res_lst_lst[0]
res = []
for j in range(len(one_time)):
tmp = []
for data in res_lst_lst:
tmp.append(data[j])
res.append(statistics.mean(tmp))
print res
graph.plot(range(1,int(args[1])+1), res)
def draw_columns1(a_lst, height, column_width):
graph.ouvre_fenetre(height, get_image_width(a_lst, column_width))
for y in range(height):
for x in range(get_image_width(a_lst, column_width)):
if not a_lst[get_column_number(x, column_width)]:
graph.plot(y, x)
graph.attend_fenetre()
def noir(haut, larg):
"""
Creation d'une fenetre __noire__ 400x600
"""
for y in range(haut): # parcourt les lignes y
for x in range(larg): # parcourt les colonnes x
graph.plot(y, x)
return
def damier(width, height, length):
for y in range(height):
offset = 0
if get_column_number(y, length) % 2 != 0:
offset = 1
for x in range(width):
if get_column_number(x, length) % 2 - offset != 0:
graph.plot(y, x)
def bande_noire_gauche(haut, larg, larg_bande):
"""
Colorie une bande noire de largeur larg_band a gauche de la fenetre
"""
for y in range(haut):
for x in range(larg):
if x < larg_bande:
graph.plot(y, x)
return
def rectangle_noir(haut, larg, ymin, ymax, xmin, xmax):
"""
Colorie un rectangle noir compris entre (xmin, xmax) horizontalement
et (ymin, ymax) verticalement (fond blanc)
"""
for y in range(ymin, ymax):
for x in range(xmin, xmax):
graph.plot(y, x)
return
def conditional_checkerboard(height, length, box_width):
for y in range(height):
for x in range(length):
if (x % (2 * box_width) < box_width or y %
(2 * box_width) < box_width) and (x %
(2 * box_width) > box_width
or y %
(2 * box_width) > box_width):
graph.plot(y, x)
def rectangle_blanc(haut, larg, ymin, ymax, xmin, xmax):
"""
Colorie un rectangle blanc compris entre (xmin, xmax) horizontalement
et (ymin, ymax) verticalement sur fond noir
"""
for y in range(haut):
for x in range(larg):
if not (x >= xmin and x < xmax and y >= ymin and y < ymax):
graph.plot(y, x)
return
def dessine_bandes1(lst, hauteur, largeur_bandes):
largeur = largeur_image(lst, largeur_bandes)
graph.ouvre_fenetre(hauteur, largeur)
# parcour pixels
for y in range(hauteur):
for x in range(largeur):
nb = num_bande(x, y, largeur_bandes)
if lst[nb] == 0:
graph.plot(y, x)
# graph.attend_fenetre()
return
def rayures_verticales_naif(hauteur, largeur, larg_bande):
"""
Dessine des rayures verticales de largeur larg_bande
alternant blanc et noir sur une fenetre de taille
hauteur x largeur.
Il n'y a aucune condition necessaire pour larg_bande.
**Algorithme naif**
"""
for x in range(largeur):
if bande_est_noire(numero_bande(x, larg_bande)):
for y in range(hauteur):
graph.plot(y, x)
return
def rectangle_random(haut, larg, ymin, ymax, xmin, xmax):
"""
Colorie un rectangle de couleur aleatoire compris entre (xmin, xmax)
horizontalement et (ymin, ymax) verticalement (fond blanc)
"""
couleurs = [
"black", "white", "red", "green", "blue", "yellow", "cyan", "magenta",
"orange", "darkgrey"
]
# on choisit une couleur au hasard
c = couleurs[int(random.random() * len(couleurs))]
for y in range(ymin, ymax):
for x in range(xmin, xmax):
graph.plot(y, x, c)
return
def updated_model_with_errors(parameter):
layout = {
'yaxis': {
'range': [0, 450],
'title': 'sales'
},
'xaxis': {
'title': 'ad spend'
}
}
inputs = list(range(1500, 4500, 250))
predictions = list(
map(lambda ad_spend: parameter * ad_spend, observed_ad_spends))
data_trace = trace_values([2000, 3500, 4000], [260, 445, 490],
name='actual sales')
predictions_trace = trace_values(observed_ad_spends,
predictions,
'lines',
name='predictions')
y_values_y_hats = list(zip(observed_sales, predictions))
errors = list(map(lambda pair: pair[0] - pair[1], y_values_y_hats))
error_traces = error_line_traces(observed_ad_spends, observed_sales,
errors)
return plot([data_trace, predictions_trace] + error_traces)
def plot_data_and_model():
inputs = list(range(1500, 4500, 250))
predictions = list(map(lambda input: .15*input,inputs))
predictions_trace = trace_values(inputs, predictions, 'lines', name = 'predictions')
data_trace = trace_values([2000, 3500, 4000], [260, 445, 490], name = 'actual sales')
layout = {'yaxis': {'range': [0, 18], 'title': 'sales'}, 'xaxis': {'title': 'ad spend'}}
return plot([data_trace, predictions_trace])
def damier_naif(hauteur, largeur, cote):
"""
Dessine un damier de case carees de largeur cote
alternant blanc et noir sur une fenetre de taille
hauteur x largeur.
Il n'y a aucune condition necessaire pour cote et la premiere case
est blanche.
**Algorithme naif**
"""
for x in range(largeur):
for y in range(hauteur):
nv, nh = numero_case(x, y, cote)
if case_est_noire(nv, nh):
graph.plot(y, x)
return
def rainbow_damier(width, height, length):
cases = []
last_column = -1
for y in range(height):
offset = 0
y_column = get_column_number(y, length)
if last_column != y_column:
cases.append([get_random_color()])
last_column = y_column
if y_column % 2 != 0:
offset = 1
for x in range(width):
x_column = get_column_number(x, length)
if x_column == len(cases[y_column]):
cases[y_column].append(get_random_color())
if x_column % 2 - offset != 0:
graph.plot(y, x, cases[y_column][x_column])
def plot_data_and_errors():
inputs = list(range(1500, 4500, 250))
predictions = list(map(lambda input: .15*input,inputs))
predictions_trace = trace_values(inputs, predictions, 'lines', name = 'predictions')
errors = [-40, -80, -110]
ad_spends = [2000, 3500, 4000]
sales = [260, 445, 490]
error_traces = error_line_traces(ad_spends, sales, errors)
return plot([data_trace, predictions_trace] + error_traces)
def predictFromFile2(fn,top):
fn=sn.getSentenceFile(fn)
global fl,csvdata
csvdata=pd.DataFrame(columns=('line',"joy","trust","fear","surprise","sadness","disgust","anger","anticipation"))
if fl ==0:
init(top)
f=open(fn,"r+")
data = f.readlines()
l=0
for line in data:
l+=1
#top.pr ("\n"+line)
stemArr = getStems(line)
#top.pr(predict2(stemArr))
predict2(stemArr,l)
csvdata.to_csv(fn+".csv",index=False)
graph.plot(fn)
def measure_encrypt(message, bits_limit):
"""
Realiza o benchmark do processo de geração de chaves, comparando fermat e miller.
O resultado desse procedimento é gravado em um arquivo na pasta /time.
message - mensagem a ser criptografada
bits_limit - número de bits limite para realizar benchmark
"""
timesAverage = 10
fermatEncrypt, [] = rsa_benchmark(message,
bits_limit,
encryptMethod="fermat",
timesAverage=timesAverage)
millerEncrypt, [] = rsa_benchmark(message,
bits_limit,
encryptMethod="miller",
timesAverage=timesAverage)
plotEncrypt = {"fermat": fermatEncrypt, "miller": millerEncrypt}
plot(valuesY=plotEncrypt, title="Encrypt", bits=bits_limit)
def plot_data_and_errors():
inputs = [.30, .40, .50, .60, .70]
predictions = list(map(lambda angle: 40 * angle, inputs))
predictions_trace = trace_values(inputs,
predictions,
'lines',
name='predictions')
errors = [-4, -9, -11]
error_traces = error_line_traces(observed_shot_angles, observed_distances,
errors)
return plot([data_trace, predictions_trace] + error_traces)
def rectangle_couleur(ymin,
ymax,
xmin,
xmax,
couleur,
outline_color="black",
outline_thick=0):
for y in range(ymin, ymax):
for x in range(xmin, xmax):
graph.plot(y, x, couleur=couleur)
for x in range(xmin, xmin + outline_thick):
for y in range(ymin, ymax):
graph.plot(y, x, couleur=outline_color)
for x in range(xmax - outline_thick, xmax):
for y in range(ymin, ymax):
graph.plot(y, x, couleur=outline_color)
for y in range(ymin, ymin + outline_thick):
for x in range(xmin, xmax):
graph.plot(y, x, couleur=outline_color)
for y in range(ymax - outline_thick, ymax):
for x in range(xmin, xmax):
graph.plot(y, x, couleur=outline_color)
return
def plot_data_and_model():
model_trace = trace_values(angles,
predicted_distances,
mode='lines',
name='model')
layout = {
'yaxis': {
'range': [0, 18],
'title': 'shot distance'
},
'xaxis': {
'title': 'shot angle'
}
}
return plot([data_trace, model_trace])
def measure_break(message, bits_limit):
"""
Realiza o benchmark do processo quebra de chaves.
O resultado desse procedimento é gravado em um arquivo na pasta /time.
message - mensagem a ser criptografada
bits_limit - número de bits limite para realizar benchmark
"""
timesAverage = 1
pollardBreak = rsa_benchmark(message,
bits_limit,
breakMethod="pollard",
timesAverage=timesAverage)
pollardBreak = pollardBreak[1]
bruteBreak = rsa_benchmark(message,
bits_limit,
breakMethod="brute",
timesAverage=timesAverage)
bruteBreak = bruteBreak[1]
plotBreak = {"pollard": pollardBreak, "brute force": bruteBreak}
plot(valuesY=plotBreak, title="Break Key", bits=bits_limit)
def main():
trainingparams = [0.01, 0.02, 0.03, 0.125, 0.625, 1]
iterations = 5
eta = 0.001
epsilon = 0.001
valuerange = 10
params = []
data = utils.getdata('breast-cancer-wisconsin.data.txt')
nb = naivebayes.naivebayes(data, trainingparams, iterations, valuerange)
nb['label'] = 'Naive Bayes'
lr = logisticregression.logisticregression(data, trainingparams,
iterations, eta, epsilon)
lr['label'] = 'Logistic Regression'
params.append(lr)
params.append(nb)
plot = graph.plot(params, 'Training Set', 'Accuracy')
plot.show()
return
def updated_model_with_errors(parameter):
layout = {
'yaxis': {
'range': [0, 18],
'title': 'shot distance'
},
'xaxis': {
'title': 'shot angle'
}
}
predictions = list(
map(lambda angle: parameter * angle, observed_shot_angles))
actual_trace = trace_values(observed_shot_angles,
observed_distances,
name='actual shots')
predictions_trace = trace_values(observed_shot_angles,
predictions,
'lines',
name='predictions')
y_values_y_hats = list(zip(observed_distances, predictions))
errors = list(map(lambda pair: pair[0] - pair[1], y_values_y_hats))
error_traces = error_line_traces(observed_shot_angles, observed_distances,
errors)
return plot([actual_trace, predictions_trace] + error_traces)
forces(f_spring, K, A, coords, species, cell, C=C) # edge forces
+ forces(f_spring, pK_B, pA_B, coords, species, cell, C=C,
repel=False) # B pseudoedge forces
+
forces(f_spring, pK_Si, pA_Si, coords, species, cell, C=C,
repel=False) # Si pseudoedge forces
][0] # (wrapped in list only to facilitate commenting out pseudoedge lines)
E_arr = energies(F) # energy per node (F**2)
E, E0 = np.sum(E_arr), E # total energy
print E, count, progress
if E < Si_O * .001 * len(G.V) or count > 200 or progress < -5:
break
# broadcast E_arr (i.e. F_sq) to same shape as F
Fsq_vector = np.vstack([E_arr] * len(coords)).transpose()
# shift coords by step * unit vector
""" is there a sensible way to include force magnitude somehow?"""
shift = step * F / Fsq_vector**(0.5)
coords += shift.transpose()
# if cell boundaries were defined, enforce periodicity
if cell != None:
for i, length in enumerate(cell):
coords[i] %= length
step, progress = update_step(step, E, E0, progress)
plot(coords, A, G.nSi, G.nB, G.nO, cell)
"partitions",
"VAR",
"sum u(x)",
"cor_cost",
"sp2_cost",
"cor_means",
"sp2_means",
"time_coreset",
"time_kmeans",
"time_cost",
"time_spark",
],
)
dump(
"avg",
data1,
[runtag, "ref-cost: ", ref_cost, " total-time:", r(total_time, 1)],
["partitions", "VAR", "coreset weights avg", "coreset avg cost", "uniform avg cost"],
)
dump(
"mis",
data2,
[runtag, "ref-cost:", ref_cost],
["partitions", "VAR", "cset weights avg", "cset mistake", "spark mis", "time cset", "time spark"],
)
un = [y_un, t_un] if run["uni"] else None
graph.plot(
x_ax, [y_cs, t_cs, t_csg], [y_sp2, t_sp], None, un, show=plot["result"], labels=[xlabel, runtg[1], runtg[2]]
)
sendStr += str(strftime("%H:%M", gmtime()))
sendStr += " "
sendStr += str(data)
f.write(sendStr) # python will convert \n to os.linesep
f.close() # you can omit in most cases as the destructor will call it
s.send('5')
f1 = s.makefile()
data = str(f1.readline())
print "HS2: ",data
f1 = open('plotVal2','a')
sendStr = ""
sendStr += str(strftime("%H:%M", gmtime()))
sendStr += " "
sendStr += str(data)
f1.write(sendStr)
f1.close()
# f2 = open('plotValues','a')
# f2.write(data) # python will convert \n to os.linesep
# f2.close() # you can omit in most cases as the destructor will call it
gr.plot(0,0)
gr.plot(0,1)
s.close()
except socket.error, exc:
print "Caught exception socket.error : %s" % exc
time.sleep (10)
def white_rectangle(height, length, y1, y2, x1, x2):
for y in range(height):
for x in range(length):
if x <= x1 or x >= x2 or y <= y1 or y >= y2:
graph.plot(y, x)
sendStr = ""
sendStr += str(strftime("%H:%M", gmtime()))
sendStr += " "
sendStr += str(data)
f.write(sendStr) # python will convert \n to os.linesep
f.close() # you can omit in most cases as the destructor will call it
s.send('5')
f1 = s.makefile()
data = str(f1.readline())
print "HS2: ", data
f1 = open('plotVal2', 'a')
sendStr = ""
sendStr += str(strftime("%H:%M", gmtime()))
sendStr += " "
sendStr += str(data)
f1.write(sendStr)
f1.close()
# f2 = open('plotValues','a')
# f2.write(data) # python will convert \n to os.linesep
# f2.close() # you can omit in most cases as the destructor will call it
gr.plot(0, 0)
gr.plot(0, 1)
s.close()
except socket.error, exc:
print "Caught exception socket.error : %s" % exc
time.sleep(10)
def noir(height, length):
for y in range(height):
for x in range(length):
graph.plot(y, x)
def profMethod_vertical_strip(height, length, band_width):
for l in range(height):
for c in range(length):
if c % (2 * band_width) > band_width:
graph.plot(l, c)
