def __init__(self):
super().__init__()
self.setupUi(self)
self.hexColor.setFocus()
self.hexColor.returnPressed.connect(self.set_color)
self.okButton.clicked.connect(self.set_color)
self.pasteButton.clicked.connect(self.paste_text)
self.whites: Set[int] = helper.get_white_color_codes()
self.d = readFile.read_file()
import readFile
readFile.read_file()
files=readFile.files
lst=readFile.lst
directory=readFile.directory
def lcs(S,T):
m = len(S)
n = len(T)
counter = [[0]*(n+1) for x in range(m+1)]
longest = 0
length=0
for i in range(m):
for j in range(n):
if S[i] == T[j]:
c = counter[i][j] + 1
counter[i+1][j+1] = c
if c > longest:
longest = c
length=len(S[i-c+1:i+1])
elif c == longest:
length=len(S[i-c+1:i+1])
return int((2*(length-1)/(len(S)+len(T)))*100)
#Comparing all the lists of files.
for i in range(0,(len(files)-1)):
for j in range((i+1),len(files)):
try:
print("Plagiarism between ",files[i],"and ",files[j]," is: ",str(lcs(directory[files[i]],directory[files[j]])),"%",)
except:
print(files[i]," and ",files[j]," are empty.")
print()
from Model import train_using_default_dict
from Model import test
from readFile import read_file
if __name__ == "__main__":
read_file('Chat_with_Bhai_jio.txt')
train_using_default_dict('chat.txt')
#train_using_default_dict('Sample.txt')
print("Enter sample text to be searched--")
user_input = str(input())
test(user_input)
from visualize import animate
from connector import turns_connector, k_regret_connector
import numpy as np
def calculate_path_dist(history_cycles, distance_matrix):
distance1 = calculate_dist_of_given_cycle(history_cycles[0],
distance_matrix)
distance2 = calculate_dist_of_given_cycle(history_cycles[1],
distance_matrix)
return distance1, distance2
if __name__ == '__main__':
data_set = 'kroB'
overview, coordinates = read_file('data/' + data_set + '100.tsp')
print(overview)
distance_matrix = count_dist(coordinates)
# resc, histc = greedy_cycle(distance_matrix, start_with=10)
# resp, histp = greedy_nearest_neighbour(distance_matrix, start_with=10)
results = []
for x in range(100):
history_gc, picked_nodes = turns_connector(
[greedy_cycle_propose, greedy_cycle_propose], distance_matrix)
gc_dist_1, gc_dist_2 = calculate_path_dist(history_gc[-1],
distance_matrix)
results.append([gc_dist_1 + gc_dist_2, picked_nodes])
# animate(history_gc, coordinates, cycle=[True, True])
# Author: Antonio Cruz
# Creation date: June,19,2018
# This code is divided mainly in 2 parts:
# I.) A K-shortest path function based on the Dijkstra algorithm
# II.) Graph Network modeling and analysis
#
#
# I. A KSP algorithm determines the amount(K) of shortest paths given from a source node to a destination node
# Most KSPs are based in the Dijkstra algorithm
# For this project, the KSP algorithm has been altered so it can also be applied to areas inside the links,
# This means that the KSP can determine the distance from either Node to Node, or from Node to a specified Point
# in the link.
#
# II.
#
#
#
from NodeClass import Node
from readFile import read_file
# from EdgeClass import Edge
b_list = Node(2, 3, 5.2, 2.1, 1.2)
listing = read_file("Distance.txt")
listing[0].dec_print()
print "OOOOOOOOOOOOOOO"
listing[1].dec_print()
def classify_email(filename):
x = email_features(process_email(read_file(filename), 'vocab.txt')).reshape(1, -1)
pred = model.predict(x)
print('\nProcessed {}\n\nSpam Classification: {}\n'.format(filename, pred))
print('(1 indicates spam, 0 indicates not spam)\n\n')
def pause():
input("")
"""## Part 1: Email Pre-processing
To use an SVM to classify emails into Spam v.s. Non-Spam, you first need
to convert each email into a vector of features. In this part, you will
implement the pre-processing steps for each email. You should
complete the code in processEmail.py to produce a word indices vector
for a given email."""
print('\nPre-processing sample email (emailSample1.txt)\n')
# Extract Features
file_contents = read_file('emailSample1.txt')
word_indices = process_email(file_contents, 'vocab.txt')
# Print Stats
print('Word Indices: \n')
print(word_indices)
print('\n\n')
print('Program paused. Press enter to continue.\n')
pause()
"""
## Part 2: Feature Extraction
Convert each email into a vector of features in R^n.
"""
print('\nExtracting features from sample email (emailSample1.txt)\n')
def getWordFrequency(filename): text = read_file(filename) words = getWordsFromText(text) frequencyMap = countFrequency(words) return frequencyMap
def solve(file_name):
'''
This function takes in the lazor file name, calculates the block positions
to solve the lazor file, and saves a file with the solution
inputs
file_name: name of the board file to be read
outputs
None
'''
# Load lazor file variables
Grid, fixed_Blocks, Blocks, Lazor_Path, Lazor_Dir, m, b, not_allowed, t, P = read_file(file_name)
# Specify how many of each block type there are
num_reflect = Blocks[0]
num_opaque = Blocks[1]
num_refract = Blocks[2]
num_blocks = sum(Blocks)
# for each block define it as an object and store in blocks variable
blocks = []
block_type = []
for i in range(1, num_reflect+1):
block_type.append('reflect')
for i in range(1, num_opaque+1):
block_type.append('opaque')
for i in range(1, num_refract+1):
block_type.append('refract')
fixed_blocks_type = []
fixed_blocks_pos = []
# for loop that organizes the fixed blocks positions and types
for i in range(len(fixed_Blocks)):
fixed_blocks_type.append(fixed_Blocks[i].block_type)
fixed_blocks_pos.append(list(fixed_Blocks[i].position))
fixed_blocks_pos[i] = [fixed_blocks_pos[i][1]+1, fixed_blocks_pos[i][0]+1]
# not allowed are positions with a fixed block or no space
not_allowed = [[not_allowed[i][1]+1, not_allowed[i][0]+1] for i in range(len(not_allowed))]
# create blocks allowed variable, all spots a block is allowed
blocks_allowed = [[i+1, j+1] for i in range(len(Grid)) for j in range(len(Grid[0])) if [i+1, j+1] not in not_allowed]
# orientating the block positions in x, y format
xyblocks = []
for i in range(len(blocks_allowed)):
xyblocks.append([blocks_allowed[i][1], blocks_allowed[i][0]])
# converts the allowed coordinates into single numbers correlating to the
# coordinate position
num_allowed = []
for i in range(len(xyblocks)):
num_allowed.append(functions.coord_to_num(Grid, xyblocks[i]))
# determines the number of type of blocks we have
num_types = sum([1 for i in range(len(Blocks)) if Blocks[i] != 0])
# determines the blocks behind and infront of the lazor
behind, forward = functions.block_behind_lazor(Lazor_Path, Lazor_Dir, Grid)
# checks if we only have one block type and if so cuts down on the
# number of valid combinations for the blocks
if num_types == 1:
combos = []
combo = list(combinations(num_allowed, len(block_type)))
common_blocks_num = functions.valid_positions(Lazor_Path, xyblocks, Grid)
i = 0
totalBlocks = len(Grid[0])*len(Grid)
allblocks = [i for i in range(1, totalBlocks+1)]
avg = sum(allblocks)/len(allblocks)
for i in range(len(combo)):
if any(x in common_blocks_num for x in combo[i]):
summ = 0
k = 0
c = list(combo[i])
for k in range(len(block_type)):
summ = summ + combo[i][k]
bavg = summ/k
absvalue = abs(avg - bavg)
c.append(absvalue)
combos.append(tuple(c))
combos = list(set(combos))
else:
common_blocks_num = functions.valid_positions(Lazor_Path, blocks_allowed, Grid)
combos = functions.get_combos(block_type, num_allowed, common_blocks_num, Grid, behind, forward)
# fix things that need to be reinitialized at beginning of each while loop
fixed_LP = copy.deepcopy(Lazor_Path)
fixed_LD = copy.deepcopy(Lazor_Dir)
fixed_m = copy.deepcopy(m)
fixed_b = copy.deepcopy(b)
# set all of the branches for the refract block
branch = False
branch_1 = None
branch_2 = None
branch_1_dir = None
branch_2_dir = None
total_laze = len(m) # total number of lazors
num = 0
used_contact_pos = []
target_check = np.multiply(sum(m), t)
# loop that will run while the correct combo is not chosen
while not np.array_equal(target_check, 2*t):
num = num+1
blocks = []
chosen_combo = combos[0]
# place each block
for j in range(len(block_type)):
# if the num type is 1, we need to adjust the combo sequence
if num_types == 1:
b_type = block_type[0]
b_pos = chosen_combo[j]
b_pos = functions.num_to_coord(Grid, b_pos)
else:
b_type = chosen_combo[j]
b_pos = chosen_combo[j+num_blocks]
b_pos = functions.num_to_coord(Grid, b_pos)
# create the blocks as objects
blocks.append(Block(b_type, tuple(b_pos)))
blocks[j].add_blocks(b)
# loop through each of the lazors
for i in range(len(m)):
lazor_num = i
used_contact_pos = []
# check for blocks behind the lazor
behind_coord = None
if behind[i] is not None:
behind_coord = functions.num_to_coord(Grid, behind[i])
# determining the contact position characteristics
contact_position, x_dir, y_dir, contact_index, contact_side, contact_list, used_contact_pos, all_contact_pos = functions.lazor_contact_tuple(m[lazor_num], b, Lazor_Path, Lazor_Dir, lazor_num, used_contact_pos, total_laze)
# while there are still contact positions, continue to adjust the
# lazor
while contact_position is not None:
# get the block and block type of the contact position
block, b_type = functions.find_block_type(blocks, b, contact_position)
b_pos_now = block.pos()
# check if the block is refract, and if so update the branches
if b_type == "refract":
used_contact_pos.extend(all_contact_pos)
# check special checks if the block is at the position behind
# where the lazor starts
if functions.check_special(list(b_pos_now), behind_coord) is False:
special = False
new_x_dir, new_y_dir, delete_after_contact = block.block_prop(x_dir, y_dir, contact_side)
Lazor_Path, Lazor_Dir, m[lazor_num] = functions.add_to_lazor_path(block, contact_position, m[lazor_num], Lazor_Path, Lazor_Dir, lazor_num, new_x_dir, new_y_dir, contact_index, contact_side, delete_after_contact, total_laze, used_contact_pos, special)
# if a branch exists, adjust the branches accordingly
if branch is True:
refract_branch, refract_branch_dir = functions.change_refract_branches(branch_1, branch_2, branch_1_dir, branch_2_dir, contact_position)
if refract_branch is None:
pass
else:
Lazor_Path[lazor_num].extend(refract_branch)
Lazor_Dir[lazor_num].extend(refract_branch_dir)
for j in range(len(refract_branch)):
m[lazor_num][refract_branch[j][1]][refract_branch[j][0]] = 2
# if the block is refract, then create new branches
if b_type == "refract":
parent, branch_1, branch_2, branch_1_dir, branch_2_dir, branch = functions.refract_branches(Lazor_Path, Lazor_Dir, lazor_num)
contact_position, x_dir, y_dir, contact_index, contact_side, contact_list, used_contact_pos, all_contact_pos = functions.lazor_contact_tuple(m[lazor_num], b, Lazor_Path, Lazor_Dir, lazor_num, used_contact_pos, total_laze)
else:
# if special is true, do not update the lazor path
special = True
new_x_dir, new_y_dir, delete_after_contact = block.block_prop(x_dir, y_dir, contact_side)
new_x_dir = x_dir
new_y_dir = y_dir
Lazor_Path, Lazor_Dir, m[lazor_num] = functions.add_to_lazor_path(block, contact_position, m[lazor_num], Lazor_Path, Lazor_Dir, lazor_num, new_x_dir, new_y_dir, contact_index, contact_side, delete_after_contact, total_laze, used_contact_pos, special)
if branch is True:
refract_branch, refract_branch_dir = functions.change_refract_branches(branch_1, branch_2, branch_1_dir, branch_2_dir, contact_position)
if refract_branch is None:
pass
else:
Lazor_Path[lazor_num].extend(refract_branch)
Lazor_Dir[lazor_num].extend(refract_branch_dir)
for j in range(len(refract_branch)):
m[lazor_num][refract_branch[j][1]][refract_branch[j][0]] = 2
if b_type == "refract":
parent, branch_1, branch_2, branch_1_dir, branch_2_dir, branch = functions.refract_branches(Lazor_Path, Lazor_Dir, lazor_num)
contact_position, x_dir, y_dir, contact_index, contact_side, contact_list, used_contact_pos, all_contact_pos = functions.lazor_contact_tuple(m[lazor_num], b, Lazor_Path, Lazor_Dir, lazor_num, used_contact_pos, total_laze)
# reset the target check, m, b, lazor path, lazor path,
# and remove the previously tested combo
target_check = np.multiply(sum(m), t)
combos.remove(chosen_combo)
Lazor_Path_sol = Lazor_Path
m = copy.deepcopy(fixed_m)
b = copy.deepcopy(fixed_b)
branch = False
Lazor_Path = copy.deepcopy(fixed_LP)
Lazor_Dir = copy.deepcopy(fixed_LD)
# save the output as a png file
save_file.save_file(file_name, Grid, blocks, Lazor_Path_sol, P)
def classify_email(filename):
x = email_features(process_email(read_file(filename),
'vocab.txt')).reshape(1, -1)
pred = model.predict(x)
print('\nProcessed {}\n\nSpam Classification: {}\n'.format(filename, pred))
print('(1 indicates spam, 0 indicates not spam)\n\n')
def pause():
input("")
"""## Part 1: Email Pre-processing
To use an SVM to classify emails into Spam v.s. Non-Spam, you first need
to convert each email into a vector of features. In this part, you will
implement the pre-processing steps for each email. You should
complete the code in processEmail.py to produce a word indices vector
for a given email."""
print('\nPre-processing sample email (emailSample1.txt)\n')
# Extract Features
file_contents = read_file('emailSample1.txt')
word_indices = process_email(file_contents, 'vocab.txt')
# Print Stats
print('Word Indices: \n')
print(word_indices)
print('\n\n')
print('Program paused. Press enter to continue.\n')
pause()
"""
## Part 2: Feature Extraction
Convert each email into a vector of features in R^n.
"""
print('\nExtracting features from sample email (emailSample1.txt)\n')
