def __init__(self, env, type, conf, loggers):
self.env = env
self.conf = conf
self.topology = {}
self.type = type
self.loggers = loggers
self.clients = [Client(env, conf, self, loggers = loggers, label=0) for i in range(int(conf["clients"]["number"]))]
if type == "p2p":
self.peers = [Node(env, conf, self, id="Peer%s" % i, loggers = loggers) for i in range(int(conf["clients"]["number"]))]
self.topology["Type"] = "p2p"
self.init_p2p()
else:
if type == "cascade":
self.topology["Type"] = "cascade"
self.mixnodes = [Node(env, conf, self, id="M%s" % i, loggers = loggers) for i in range(self.conf["network"]["cascade"]["cascade_len"])]
self.init_cascade()
elif type == "stratified":
self.topology["Type"] = "stratified"
num_mixnodes = int(self.conf["network"]["stratified"]["layers"]) * int(self.conf["network"]["stratified"]["layer_size"])
self.mixnodes = [Node(env, conf, self, id="M%s" % i, loggers = loggers) for i in range(num_mixnodes)]
self.init_stratified()
elif type == "multi_cascade":
self.topology["Type"] = "multi_cascade"
num_mixnodes = int(self.conf["network"]["multi_cascade"]["cascade_len"]) * int(self.conf["network"]["multi_cascade"]["num_cascades"])
self.mixnodes = [Node(env, conf, self, id="M%s" % i, loggers = loggers) for i in range(num_mixnodes)]
self.init_multi_cascade()
else:
raise Exception("Didn't recognize the network type")
print("Current topology: ", self.topology["Type"])
def insert(self, proj, point, currentNode=None):
'''
Inserts a node into the subtree rooted at this node.
Args:
currentNode: The node to be inserted.
proj: Projection of a point onto unit vector
point: Query Point
Time Complexity: O(log(n))
'''
if self.root == None:
self.root = Node(proj, point)
return
if proj < currentNode.proj:
if currentNode.left is None:
currentNode.left = Node(proj, point, parent=currentNode)
self.update_balance(currentNode.left)
else:
self.insert(proj, point, currentNode.left)
elif proj > currentNode.proj:
if currentNode.right is None:
currentNode.right = Node(proj, point, parent=currentNode)
self.update_balance(currentNode.right)
else:
self.insert(proj, point, currentNode.right)
else:
currentNode.points.append(point)
def test_store_file():
target_id = utility.default_id
n = Node(1000)
n.load_kbucket('nodeA.csv')
x = n.store_file(
'file.txt',
r'C:\Users\roykc\Documents\Projects\d-p2p-fsn\tests\file.txt')
print('in my shared files: ', n.my_shared_files)
def test_node_lookup():
target_id = utility.default_id
n = Node(1000)
n.load_kbucket('nodeA.csv')
x = n._node_lookup(target_id)
print('node lookup answer:', x)
for triple in x:
print(utility.distance(triple.id, target_id))
def else_block(self):
children = []
children.append(Node("NO_WAI_KEYWORD"))
self.eat("NO_WAI_KEYWORD")
codeblock = self.codeblock([], True)
children.append(codeblock)
return Node("ELSE",children=children)
def initialization(self):
children = []
children.append(Node("ITZ_KEYWORD"))
self.eat("ITZ_KEYWORD")
value_node = self.value()
children.append(value_node)
return Node("INITIALIZATION", children = children)
def gimmeh(self):
children = []
if(self.current_token.type == "GIMMEH_KEYWORD"):
children.append(Node("GIMMEH_KEYWORD"))
self.eat("GIMMEH_KEYWORD")
children.append(self.variable())
else:
return False
return Node("INPUT",children=children)
def __set_nodes(self, gd):
nr = 0
for x_iter in range(gd.nW):
for y_iter in range(gd.nH):
xx = self.dx * x_iter
yy = self.dy * y_iter
if xx == 0 or yy == 0 or xx == gd.W or yy == gd.H:
self.nodes[nr] = Node(nr + 1, 0, xx, yy, True)
else:
self.nodes[nr] = Node(nr + 1, 0, xx, yy, False)
nr = nr + 1
def if_block(self):
children = []
children.append(Node("YA_RLY_KEYWORD"))
self.eat("YA_RLY_KEYWORD")
codeblock = self.codeblock([], True)
children.append(codeblock)
return Node("IF",children=children)
def number(self):
children = []
if (self.current_token.type == "NUMBR"):
children.append(Node("NUMBR",value = self.current_token.name))
self.eat("NUMBR")
else:
children.append(Node("NUMBAR",value = self.current_token.name))
self.eat("NUMBAR")
return Node("NUMBER", children = children)
def add_head(self, value):
'Adiciona um elemento no inicio da lista'
node = Node(value, None)
if self.__head is None:
self.__head = node
self.__tail = node
self.__size += 1
else:
node.set_next_element(self.__head)
self.__head = node
self.__size += 1
def case_block(self):
children = []
if self.current_token.type == "OMG_KEYWORD":
children.append(Node("OMG_KEYWORD"))
self.eat("OMG_KEYWORD")
children.append(self.value())
self.end()
children.append(self.codeblock([], True))
else:
return False
return Node("CASE",children = children)
def generate_tree(data, ignored_indexes=[]):
if len(data) == 0:
return Node(None, None, [])
if len(data[0]) - len(ignored_indexes) == 1:
return Node(count_classes(data), None, [])
best_expression, divided_data = split_data(data, ignored_indexes)
ignored_indexes.append(best_expression.col_index)
children = []
for sub_data in divided_data:
children.append(generate_tree(sub_data, ignored_indexes))
return Node(None, best_expression, children)
def defaultcase_block(self):
children = []
if self.current_token.type == "OMGWTF_KEYWORD":
children.append(Node("OMGWTF_KEYWORD"))
self.eat("OMGWTF_KEYWORD")
self.end()
children.append(self.codeblock([], True))
else:
return False
return Node("DEFAULTCASE",children = children)
def concatenation(self):
children = []
# SMOOSH
if (self.current_token.type == "SMOOSH_KEYWORD"):
self.eat("SMOOSH_KEYWORD")
children.append(Node("SMOOSH_KEYWORD"))
else:
return False
# <strconcat>
children.append(self.strconcat())
return Node("CONCATENATION", children = children)
def print(self):
children = []
# VISIBLE
if(self.current_token.type == "VISIBLE_KEYWORD"):
children.append(Node("VISIBLE_KEYWORD"))
self.eat("VISIBLE_KEYWORD")
else:
return False
# <printop>
printop_node = self.printop([])
children.append(printop_node)
return Node("PRINT", children = children)
def make_first_node(grid_object, index):
"""
Create first Node and set type as first protein character.
:param grid_object: grid object
:param index: index
:return: first node
"""
first_node = Node(0, 0, 0)
first_node.type = grid_object.protein[0]
# Put in Grid
grid_object.add_point(first_node, index)
return first_node
def variable(self):
children = []
# varident
if (self.current_token.type == "VAR_IDENTIFIER"):
children.append(Node("VAR_IDENTIFIER", value = self.current_token.name))
self.eat("VAR_IDENTIFIER")
# IT
elif (self.current_token.type == "IT_KEYWORD"):
children.append(Node("IT_KEYWORD", value = self.current_token.name))
self.eat("IT_KEYWORD")
else:
return False
return Node("VARIABLE", children = children)
def __init__(self, n_horizontal_nodes: int, n_vertical_nodes: int,
gridWidth: float, gridHeight: float):
# checking input
if n_horizontal_nodes <= 1 or n_vertical_nodes <= 1:
raise ValueError(
"Grid must have positive numbers or vertical and horizontal nodes"
)
#initializing class fields
nElements = (n_horizontal_nodes - 1) * (n_vertical_nodes - 1)
nNodes = n_horizontal_nodes * n_vertical_nodes
self.__data = self.__grid_data(gridHeight, gridWidth, n_vertical_nodes, n_horizontal_nodes, \
nNodes, nElements)
self.__nodes = []
self.__elements = []
element_width = gridWidth / (n_horizontal_nodes - 1)
element_height = gridHeight / (n_vertical_nodes - 1)
#creating list of nodes
id = 1
for x in range(n_horizontal_nodes):
for y in range(n_vertical_nodes):
#border control
if (x == 0 or x == n_horizontal_nodes -
1) or (y == 0 or y == n_vertical_nodes - 1):
self.__nodes.append(
Node(id,
x * element_width,
y * element_height,
BC=True))
else:
self.__nodes.append(
Node(id,
x * element_width,
y * element_height,
BC=False))
id += 1
#creating elements of 4 nodes
elem_id = 1
for x in range(n_horizontal_nodes - 1):
for y in range(n_vertical_nodes - 1):
id = y + x * n_vertical_nodes
node_list = [
self.__nodes[id], self.__nodes[n_vertical_nodes + id],
self.__nodes[n_vertical_nodes + id + 1],
self.__nodes[id + 1]
]
self.__elements.append(Element(elem_id, 4, node_list))
elem_id += 1
def allLol(self):
children = []
if(self.current_token.type == "ALL_OF_KEYWORD"):
children.append(Node("ALL_OF_KEYWORD"))
self.eat("ALL_OF_KEYWORD")
else:
return False
all_node = self.boolop()
children.append(all_node)
children.append(Node("MKAY"))
self.eat("MKAY_KEYWORD")
return Node("ALL",children = children)
def ifthen_statement(self):
children = []
if self.current_token.type == "O_RLY?_KEYWORD":
children.append(Node("O_RLY?_KEYWORD"))
self.eat("O_RLY?_KEYWORD")
self.end()
children.append(self.if_block())
children.append(self.else_block())
else:
return False
self.eat("OIC_KEYWORD")
children.append(Node("OIC_KEYWORD"))
return Node("IFTHEN",children = children)
def random_chain(grid_object):
"""
Creates a protein chain starting at (0, 0, 0)
then filling in the grid with Nodes by doing a random move from last added
Node to the next one until it has length of whole protein string.
:param grid_object: grid object
:return: grid object
"""
# n'th Node
index = 0
# Clear grid if it exists
if not len(grid_object.grid) != 0:
grid_object.clear_grid()
grid_object.grid_chain = {}
first_node = make_first_node(grid_object, index)
# repeat until the whole protein has finished
while index < len(grid_object.protein) - 1:
# select last added Node
current_node_key = grid_object.grid_chain[index][0]
current_node = grid_object.grid[current_node_key].nodes[0]
new_x, new_y, new_z = make_new_coords(grid_object, current_node)
# if the move doesnt overlap own chain -> add to grid
if not grid_object.overlap(new_x, new_y, new_z):
index += 1
new_node = Node(new_x, new_y, new_z)
new_node.n = index
new_node.type = grid_object.protein[index]
grid_object.add_point(new_node, index)
# start over if chain is stuck
if grid_object.chain_stuck(new_x, new_y, new_z):
index = 0
grid_object.clear_grid()
grid_object.grid_chain = {}
grid_object.add_point(first_node, index)
grid_object.update_all_bonds()
return grid_object
def insert(self, x):
""" insert x into binary tree
"""
x = int(x)
if self.root():
self.root().insert(x)
else:
self.root(Node(x))
def break_statement(self):
if self.current_token.type == "GTFO_KEYWORD":
self.eat("GTFO_KEYWORD")
else:
return False
return Node("GTFO_KEYWORD")
def a_star_search_algorithm(boardSetUp):
global puzzleConfigFileOutput, TIMEOUT_TIME, finalFileOutput
heuristic = calculate_h_n_manhattan_distance(boardSetUp.board)
totalTime = 0
startTime = time.time()
start = Node(0, heuristic, "", boardSetUp)
if heuristic == 0:
print_final_board(start)
return
open_list = PriorityQueue()
count = 0
open_list.put((start.f_n, count, start))
count += 1
closed_list = {}
while not open_list.empty():
current = open_list.get()[2]
closed_list[get_string_representation(current.boardSetUp.board)] = True
children_boards = get_children_boards(current)
for child_board in children_boards:
board_string = get_string_representation(child_board.board)
if board_string in closed_list:
continue
heuristic = calculate_h_n_manhattan_distance(child_board.board)
move = get_e_letter(child_board)
new_node = Node(current.g_n + 1, heuristic,
current.listOfMoves + move, child_board)
if heuristic == 0:
print("Solved in " + str(current.g_n + 1))
print_final_board(new_node)
return
else:
open_list.put((new_node.f_n, count, new_node))
count += 1
endTime = time.time()
totalTime += endTime - startTime
if totalTime >= TIMEOUT_TIME:
puzzleConfigFileOutput += "NO SOLUTION TO BOARD"
finalFileOutput += "NO SOLUTION TO BOARD\n"
print("Board took more than " + str(TIMEOUT_TIME) +
" seconds to solve, so it timed out")
return
else:
startTime = endTime
puzzleConfigFileOutput += "NO SOLUTION TO BOARD"
def __init__(self, gd: GlobalData):
self.__ld = gd
self.__dx = self.ld.W / (self.ld.nW - 1)
self.__dy = self.ld.H / (self.ld.nH - 1)
self.__nodes = [Node(id=nr + 1) for nr in range(self.ld.nN)]
self.__set_nodes(self.ld)
self.__elements = [
self.__set_element(self.ld, nr) for nr in range(self.ld.nE)
]
def literal(self):
children = []
# Catches all the literal
if(self.current_token.type == "YARN"):
children.append(Node("YARN", value= self.current_token.name))
self.eat("YARN")
elif(self.current_token.type == "NUMBR"):
children.append(Node("NUMBR",value= self.current_token.name))
self.eat("NUMBR")
elif(self.current_token.type == "NUMBAR"):
children.append(Node("NUMBAR",value= self.current_token.name))
self.eat("NUMBAR")
elif(self.current_token.type == "TROOF"):
children.append(Node("TROOF",value = self.current_token.name))
self.eat("TROOF")
return Node("LITERAL", children = children)
def switch_statement(self):
children = []
if self.current_token.type == "WTF?_KEYWORD":
children.append(Node("WTF?_KEYWORD"))
self.eat("WTF?_KEYWORD")
self.end()
children.append(self.caseop())
if self.current_token.type == "OMGWTF_KEYWORD":
children.append(self.defaultcase_block())
else:
self.eat("OMGWTF_KEYWORD")
else:
return False
self.eat("OIC_KEYWORD")
children.append(Node("OIC_KEYWORD"))
return Node("SWITCH",children = children)
def assign(self):
children = []
# <variable>
variable_node = self.variable()
if (variable_node):
children.append(variable_node)
else:
return False
# R
self.eat("R_KEYWORD")
children.append(Node("R_KEYWORD"))
# <value>
value_node = self.value()
children.append(value_node)
return Node("ASSIGN", children = children)
def anyLol(self):
children = []
if(self.current_token.type == "ANY_OF_KEYWORD"):
children.append(Node("ANY_OF_KEYWORD"))
self.eat("ANY_OF_KEYWORD")
else:
return False
if all_node := self.boolop():
children.append(all_node)
