def search(self, b):
# Create the root node
root = node(None, self.start)
# Initial explored set and frontier
# Frontier: queue
explorered_set = []
frontier = queue.Queue(maxsize = -1)
frontier.put(root)
while not frontier.empty():
# Expand shallowest unexpanded node
cur_node = frontier.get()
# Return when path is found
if cur_node.position == self.goal:
return path_list(cur_node)
if cur_node.position in explorered_set:
continue
possible_moves = cur_node.position.available_moves(b)
self.add_expanded_node()
explorered_set.append(cur_node.position)
for new_pos in possible_moves:
# Create child node and append to parent
child = node(cur_node, new_pos)
cur_node.add_child(child)
# Set frontier
frontier.put(child)
return []
def search(self, b):
# Create the root node
root = node(None, self.start)
# Initial explored set and frontier
# Frontier: stack
explorered_set = []
frontier = [root]
while len(frontier):
# Expand the deepest (most recent) unexpanded node
cur_node = frontier.pop()
# Return when path is found
if cur_node.position == self.goal:
return path_list(cur_node)
if cur_node.position in explorered_set:
continue
possible_moves = cur_node.position.available_moves(b)
self.add_expanded_node()
explorered_set.append(cur_node.position)
for new_pos in possible_moves:
# Create child node and append to parent
child = node(cur_node, new_pos)
cur_node.add_child(child)
# Set frontier
frontier.append(child)
return []
def search(self, b):
# Create the root node
root = node(None, self.start, 0)
# Initial explored set and frontier
# Frontier: priority queue
explorered_set = []
frontier = []
pair = (estimated_cost(root.depth, root, self.goal), root)
bisect.insort(frontier, pair)
while len(frontier):
# Expand the unexpanded node with the lowest
# estimated total path cost
cur_node = frontier.pop(0)[1]
# Return when path is found
if cur_node.position == self.goal:
return path_list(cur_node)
if cur_node.position in explorered_set:
continue
possible_moves = cur_node.position.available_moves(b)
self.add_expanded_node()
explorered_set.append(cur_node.position)
for new_pos in possible_moves:
# Create child node and append to parent
child = node(cur_node, new_pos, cur_node.depth+1)
cur_node.add_child(child)
# Set frontier
pair = (estimated_cost(child.depth, child, self.goal), child)
bisect.insort(frontier, pair)
return []
def generate_random_tree(a):
r = []
for i in range(len(a)):
r.append(i)
# initialize the tree
t = []
for i in range(0, range(len(a))):
# the id of the node is the actual value of the leaf
# however, when referring to parents or children, we still use their actual index in the array
t.append(node(a[i], -1, [], True))
while len(r) >= 2:
# continue drawing
# every time draw a pair to merge together
x = round(random.uniform(0, len(r) - 1))
v_x = r[x]
del r[x]
y = round(random.uniform(0, len(r) - 1))
v_y = r[y]
del r[y]
# replace with a new value and add to the tree
v_p = len(t)
r.append(v_p)
# connect the new node v_p with v_x and v_y
# here v_p in the index does not really matter
t.append(node(v_p, -1, [v_x, v_y], False))
t[v_x].parent = v_p
t[v_y].parent = v_p
return t
def getMove(board, roll):
validMoves = moveGen.getMoves(board, roll, 1)
treeRoots = []
#print validMoves
for validMove in validMoves:
root = tree.node()
root.name = str(validMove)
root.move = validMove
newBoard = move(board, validMove[0][0], validMove[0][1], 1)
newBoard = move(newBoard, validMove[1][0], validMove[1][1], 1)
root.board = newBoard
root.roll = roll
treeRoots.append(root)
# What complete is essentaily the first max level
# So min first then max
# Each level should then consist of a call to the min max function
# Which will min then max
highest = tree.node()
for root in treeRoots:
minMax(root)
#print root.score
#print root.name
if root.score > highest.score:
highest = root
return highest.move
def build_decision_tree(data, attributes, attributes_value, depth=0):
root = tree.node()
flag, label = is_finish(
data, attributes) #not empty, no attributes or data can't be seperated
if flag: # finish
root.set_end(label)
return root
best_attribute, median = select_best_attribute(data, attributes)
root.set_attributes(best_attribute, not attributes[best_attribute], median)
#print( best_attribute , ' ', median )
if attributes[best_attribute] == 0: #distinct
branch = tree.node()
grouped = data.groupby(best_attribute)
for value in attributes_value[best_attribute]:
if value not in grouped.groups: #数据集中该属性没有这个值
branch.set_end(label)
root.children[value] = branch
continue
group = grouped.get_group(value) #get df for the group
new_attributes = attributes.copy()
del new_attributes[best_attribute]
branch = build_decision_tree(group, new_attributes,
attributes_value)
root.children[value] = branch
return root
def p_statements(p):
"""statements : statements statement
| statement"""
if len(p) == 2:
p[0] = node('statements', ch=[p[1]], no=p.lineno(1))
else:
p[0] = node('statements', ch=[p[1], p[2]], no=p.lineno(1))
def splitBDD(BDD,c1): if len(BDD.data) > c1-1: #print type(BDD),type(BDD.cutval),type(BDD.dimCutVal),type(BDD.data),type(BDD.n1),type(BDD.n2),type(BDD.LE),type(BDD.LEM)################ cutVals = C2_criterion(BDD) BDD.n1 = tree.node(-1,-1,[],None,None,[],[]) BDD.n2 = tree.node(-1,-1,[],None,None,[],[]) for x in range(0,c1-1): if(BDD.data[x][cutVals[1]] <= cutVals[0]): BDD.n1.data.append(BDD.data[x]) else: BDD.n2.data.append(BDD.data[x]) pass pass BDD.cutval = cutVals[0] BDD.dimCutVal = cutVals[1] BDD.n1.LE = copy(BDD.LE) BDD.n1.LEM = copy(BDD.LEM) BDD.n2.LE = copy(BDD.LE) BDD.n2.LEM = copy(BDD.LEM) #supp de DATA LE et LEM du pere BDD.LE = [] BDD.LEM = [] BDD.data = [] else: pass
def p_parameters(p):
"""parameters : parameters name
| name"""
if len(p) == 2:
p[0] = node('parameters', ch=[p[1]], no=p.lineno(1))
elif len(p) == 3:
p[0] = node('parameters', ch=[p[1], p[2]], no=p.lineno(1))
def postpruning(root, data, attributes):
if (root.is_a_leaf()):
return root
new_root = tree.node()
new_root.set_attributes(root.get_attribute(), True)
branchs = root.get_child_values() #the branchs of this root node
grouped = data.groupby(root.get_attribute())
for branch in branchs:
if branch in grouped.groups: #the data have this attribute value
child_data = grouped.get_group(
branch) #the data group with attribute values branch
temp = root.get_child(branch)
new_child = postpruning(temp, child_data, attributes)
new_root.set_children(False, branch, new_child)
else: #the branch has no data to support it.
new_child = tree.node()
new_child.set_end(most_label(data))
new_root.set_children(False, branch, new_child)
no_split = tree.node()
no_split.set_end(most_label(data))
precision_pruning = model_test(no_split, data, attributes)
precision_contrast = model_test(new_root, data, attributes)
if precision_pruning >= precision_contrast: #original is better
return no_split
return new_root
def prepruning_DT(data, attributes, attributes_value, valid_data, depth=0):
root = tree.node()
flag, label = is_finish(
data, attributes) #not empty, no attributes or data can't be seperated
if flag: # finish
root.set_end(label)
return root
best_attribute, median, flag = select_best_attribute_1(
data, attributes, attributes_value, valid_data, label)
if (not flag): # flag means the split is ok
root.set_end(label)
return root
root.set_attributes(best_attribute, not attributes[best_attribute], median)
#print( best_attribute , ' ', median )
if attributes[best_attribute] == 0: #distinct
branch = tree.node()
grouped = data.groupby(best_attribute)
for value in attributes_value[best_attribute]:
if value not in grouped.groups: #数据集中该属性没有这个值
branch.set_end(label)
root.children[value] = branch
continue
group = grouped.get_group(value) #get df for the group
new_attributes = attributes.copy()
del new_attributes[best_attribute]
branch = prepruning_DT(group, new_attributes, attributes_value,
valid_data)
root.children[value] = branch
return root
def Low(father):
global lookahead, token_list, node
LOW = node()
nt_init(father, LOW, "Low", [])
if match("intc"):
T_INTC = node()
t_init(LOW, T_INTC, lookahead[1], [])
def Top(father):
global lookahead, token_list, node
TOP = node()
nt_init(father, TOP, "Top", [])
if match("intc"):
T_INTC = node()
t_init(TOP, T_INTC, lookahead[1], [])
def ProcName(father):
global lookahead, token_list, node
PROCNAME = node()
nt_init(father, PROCNAME, "ProcName", [])
if match("id"):
T_ID = node()
t_init(PROCNAME, T_ID, lookahead[1], [])
def Invar(father):
global lookahead, token_list, node
INVAR = node()
nt_init(father, INVAR, "Invar", [])
if match("id"):
T_ID = node()
t_init(INVAR, T_ID, lookahead[1], [])
def TypeId(father):
global lookahead, token_list, node
TYPEID = node()
nt_init(father, TYPEID, "TypeId", [])
if match("id"):
T_ID = node()
t_init(TYPEID, T_ID, lookahead[1], [])
def ReturnStm(father):
global lookahead, token_list, node
RETURNSTM = node()
nt_init(father, RETURNSTM, "ReturnStm", [])
if match("return"):
T_RETURN = node()
t_init(RETURNSTM, T_RETURN, "return", [])
def IdList(father):
global lookahead, token_list, node
IDLIST = node()
nt_init(father, IDLIST, "IdList", [])
if match("id"):
T_ID = node()
t_init(IDLIST, T_ID, lookahead[1], [])
IdMore(IDLIST)
def VarDec(father):
global lookahead, token_list, node
VARDEC = node()
nt_init(father, VARDEC, "VarDec", [])
if match("var"):
T_VAR = node()
t_init(VARDEC, T_VAR, "var", [])
VarDecList(VARDEC)
def VarIdList(father):
global lookahead, token_list, node
VARIDLIST = node()
nt_init(father, VARIDLIST, "VarIdList", [])
if match("id"):
T_ID = node()
t_init(VARIDLIST, T_ID, lookahead[1], [])
VarIdMore(VARIDLIST)
def Variable(father):
global lookahead, token_list, node
VARIABLE = node()
nt_init(father, VARIABLE, "Variable", [])
if match("id"):
T_ID = node()
t_init(VARIABLE, T_ID, lookahead[1], [])
VariMore(VARIABLE)
def FormList(father):
global lookahead, token_list, node
FORMLIST = node()
nt_init(father, FORMLIST, "FormList", [])
if match("id"):
T_ID = node()
t_init(FORMLIST, T_ID, lookahead[1], [])
FidMore(FORMLIST)
def FieldVar(father):
global lookahead, token_list, node
FIELDVAR = node()
nt_init(father, FIELDVAR, "FieldVar", [])
if match("id"):
T_ID = node()
t_init(FIELDVAR, T_ID, lookahead[1], [])
FieldVarMore(FIELDVAR)
def p_declaration(p):
"""declaration : type name EQUALS expression
| MAP name"""
if len(p) == 3:
p[0] = node('declaration', val=p[1], ch=p[2], no=p.lineno(1))
else:
p[0] = node('declaration',
val=p[1],
ch=[p[2], p[4]],
no=p.lineno(1))
def ProgramHead(father):
global lookahead, token_list, node
PROGRAMHEAD = node()
nt_init(father, PROGRAMHEAD, "ProgramHead", [])
if match("program"):
T_PROGRAM = node()
t_init(PROGRAMHEAD, T_PROGRAM, "program", [])
ProgramName(PROGRAMHEAD)
def get_url_path(starturl, target, limit=1):
targetSubject = get_subjects([target])[0]
startSubject = get_subjects([start])[0]
# make a tree with start url as head
head = node(starturl)
t = tree(head)
# queue of new nodes to try searching from
searchOrder = queue()
searchOrder.add(t.getHead(), subject_distance(startSubject, targetSubject))
# set of all urls that have already been searched from
allAdded = set()
allAdded.add(t.getHead().getData())
# LOOP:
# set head to current node
curr = searchOrder.pop()
targetFound = False
while not targetFound:
# get child nodes/urls of current node
currUrl = curr.getData()
# print(f"getting article: {get_subjects([currUrl])[0]}")
# if url is a valid article
if valid_url(currUrl):
childUrls = get_child_urls(currUrl)
# check if target destination in children
for url in childUrls:
# add child urls to tree as child nodes of curr
newNode = node(url)
t.add(newNode, curr)
currSubject = get_subjects([url])[0]
currDist = subject_distance(currSubject, targetSubject)
print(f"{currDist:.5f} - {currSubject}")
# if target, then return path to this node
if target.lower() == url.lower():
targetFound = True
fullPath = t.getPath(newNode)
return fullPath, len(allAdded)
else:
# if not, then add children to tree and queue for bfs
if newNode.getData() not in allAdded:
searchOrder.add(newNode, currDist)
allAdded.add(newNode.getData())
else:
print("breaking because of invalid url ^")
# change curr to next node in queue
curr = searchOrder.pop()
def AssignmentRest(father):
global lookahead, token_list, node
ASSIGNMENTREST = node()
nt_init(father, ASSIGNMENTREST, "AssignmentRest", [])
VariMore(ASSIGNMENTREST)
if match(":="):
T_ASSIGNMENT = node()
t_init(ASSIGNMENTREST, T_ASSIGNMENT, ":=", [])
Exp(ASSIGNMENTREST)
def ProcDecMore(father): global lookahead, token_list, node PROCDECMORE = node() nt_init(father, PROCDECMORE, "ProcDecMore", []) if lookahead[1] == "procedure": ProcDec(PROCDECMORE) else: T_VOID = node() t_init(PROCDECMORE, T_VOID, "ε", [])
def VarDecPart(father): global lookahead, token_list, node VARDECPART = node() nt_init(father, VARDECPART, "VarDecPart", []) if lookahead[1] == "var": VarDec(VARDECPART) else: T_VOID = node() t_init(VARDECPART, T_VOID, "ε", [])
def ProcDecpart(father): global lookahead, token_list, node PROCDECPART = node() nt_init(father, PROCDECPART, "ProcDecpart", []) if lookahead[1] == "procedure": ProcDec(PROCDECPART) else: T_VOID = node() t_init(PROCDECPART, T_VOID, "ε", [])
def TypeDecMore(father): global lookahead, token_list, node TYPEDECMORE = node() nt_init(father, TYPEDECMORE, "TypeDecMore", []) if lookahead[2] == "id": TypeDecList(TYPEDECMORE) else: T_VOID = node() t_init(TYPEDECMORE, T_VOID, "ε", [])
def BaseType(father):
global lookahead, token_list, node
BASETYPE = node()
nt_init(father, BASETYPE, "BaseType", [])
if match("integer"):
T_INTEGER = node()
t_init(BASETYPE, T_INTEGER, "integer", [])
elif match("char"):
T_CHAR = node()
t_init(BASETYPE, T_CHAR, "char", [])
def VarDecList(father):
global lookahead, token_list, node
VARDECLIST = node()
nt_init(father, VARDECLIST, "VarDecList", [])
TypeDef(VARDECLIST)
VarIdList(VARDECLIST)
if match(";"):
T_SEMICOLON = node()
t_init(VARDECLIST, T_SEMICOLON, ";", [])
VarDecMore(VARDECLIST)
def OtherTerm(father): global lookahead, token_list, node OTHERTERM = node() nt_init(father, OTHERTERM, "OtherTerm", []) if lookahead[1] in ["+", "-"]: AddOp(OTHERTERM) Exp(OTHERTERM) else: T_VOID = node() t_init(OTHERTERM, T_VOID, "ε", [])
def OtherFactor(father): global lookahead, token_list, node OTHERFACTOR = node() nt_init(father, OTHERFACTOR, "OtherFactor", []) if lookahead[1] in ["*", "/"]: MultOp(OTHERFACTOR) Term(OTHERFACTOR) else: T_VOID = node() t_init(OTHERFACTOR, T_VOID, "ε", [])
def RecType(father):
global lookahead, token_list, node
RECTYPE = node()
nt_init(father, RECTYPE, RecType, [])
if match("record"):
T_RECORD = node()
t_init(RECTYPE, T_RECORD, "record", [])
FieldDecList(RECTYPE)
if match("end"):
T_END = node()
t_init(RECTYPE, T_END, "end", [])
def CallStmRest(father):
global lookahead, token_list, node
CALLSTMTREST = node()
nt_init(father, CALLSTMTREST, "CallStmTRest", [])
if match("("):
T_LEFT_SM_COL = node()
t_init(CALLSTMTREST, T_LEFT_SM_COL, "(", [])
ActParamList(CALLSTMTREST)
if match(")"):
T_RIGHT_SM_COL = node()
t_init(CALLSTMTREST, T_RIGHT_SM_COL, ")", [])
def FieldDecMore(father): global lookahead, token_list, node FIELDDECMORE = node() nt_init(father, FIELDDECMORE, "FieldDecList", []) if lookahead[1] == "integer": FieldDecList(FIELDDECMORE) elif lookahead[1] == "char": FieldDecList(FIELDDECMORE) else: T_VOID = node() t_init(FIELDDECMORE, T_VOID, "ε", [])
def VarDecMore(father): global lookahead, token_list, node VARDECMORE = node() nt_init(father, VARDECMORE, "VarDecMore", []) if lookahead[2] == "id": VarDecList(VARDECMORE) elif lookahead[1] in ["integer", "array", "char"]: VarDecList(VARDECMORE) else: T_VOID = node() t_init(VARDECMORE, T_VOID, "ε", [])
def p_logic_expression(p):
"""logic_expression : LT expression expression
| GT expression expression
| NOT expression
| NOT call
| OR or_arg or_arg"""
if len(p) == 4:
p[0] = node('math_expression',
p[1],
ch=[p[2], p[3]],
no=p.lineno(1))
else:
p[0] = node('math_expression', p[1], ch=p[2], no=p.lineno(1))
def ParamList(father): global lookahead, token_list, node PARAMLIST = node() nt_init(father, PARAMLIST, "ParamList", []) if lookahead[2] == "id": ParamDecList(PARAMLIST) elif lookahead[1] in ["char", "integer", "array"]: ParamDecList(PARAMLIST) else: T_VOID = node() t_init(PARAMLIST, T_VOID, "ε", [])
def ProgramBody(father):
global lookahead, token_list, node
PROGRAMBODY = node()
nt_init(father, PROGRAMBODY, "ProgramBody", [])
if match("begin"):
T_BRGIN = node()
t_init(PROGRAMBODY, T_BRGIN, "begin", [])
StmList(PROGRAMBODY)
if match("end"):
T_END = node()
t_init(PROGRAMBODY, T_END, "end", [])
def p_procedure(self, p):
"""procedure : PROC NAME LBR parameters RBR NEWLINE statements_group """
if p[2] in self._functions:
sys.stderr.write(
f'>>> procedure name duplicate at {p.lineno(1)} line\n')
self.ok = False
else:
self._functions[p[2]] = node('procedure',
ch={
'parameters': p[4],
'body': p[7]
},
no=p.lineno(1))
p[0] = node('procedure_description', val=p[2])
def build_decision_tree(data, attributes, attributes_value, depth=0):
root = tree.node()
grouped = data.groupby('label')
if grouped.size().size == 1: # all belong to the same class
label = data['label'].values[0] # get the only label
root.set_end(label)
return root
flag, label = is_finish(data, attributes) #not empty
if flag: # finish
root.set_end(label)
return root
best_attribute, median = select_best_attribute(data, attributes)
if attributes[best_attribute]:
root.set_attributes(best_attribute, False, median)
else:
root.set_attributes(best_attribute, True, median)
if not attributes[best_attribute]: # not distinct
grouped = data.groupby(best_attribute)
for value in attributes_value[best_attribute]:
branch = tree.node()
if value not in grouped.groups:
label = most_label(data)
branch.set_end(label)
root.children[value] = branch
continue
group = grouped.get_group(value)
new_attributes = attributes.copy()
del new_attributes[best_attribute]
branch = build_decision_tree(group, new_attributes,
attributes_value, depth + 1)
root.children[value] = branch
else: # continue attribute
# filter, median
gtr = data[data[best_attribute] > median]
leq = data[data[best_attribute] <= median]
if gtr.shape[0] > 0:
new_attributes = attributes.copy()
del new_attributes[best_attribute]
branch1 = build_decision_tree(gtr, new_attributes,
attributes_value, depth + 1)
root.children['gtr'] = branch1
if leq.shape[0] > 0:
new_attributes = attributes.copy()
del new_attributes[best_attribute]
branch2 = build_decision_tree(leq, new_attributes,
attributes_value, depth + 1)
root.children['leq'] = branch2
return root
def p_cell_proc(p):
"""cell_proc : BAR LBR cell_arg RBR
| EMP LBR cell_arg RBR
| SET LBR cell_arg RBR
| RESET LBR cell_arg RBR
| CLR LBR cell_arg RBR"""
p[0] = node('cell_proc', p[1], ch=p[3], no=p.lineno(1))
def p_command(p):
"""command : LEFT
| RIGHT
| BACK
| STEP
| LOOK"""
p[0] = node('robot', p[1], no=p.lineno(1))
def p_statements_group(p):
"""statements_group : LPAREN statements inner_statement RPAREN
| inner_statement"""
if len(p) == 5:
p[0] = node('statements', ch=[p[2], p[3]], no=p.lineno(1))
else:
p[0] = p[1]
def p_while(p):
"""while : WHILE logic_expression DO NEWLINE statements_group"""
p[0] = node('while',
ch={
'condition': p[2],
'body': p[5]
},
no=p.lineno(1))
def p_call_err0(p):
"""cell_proc : BAR error
| EMP error
| SET error
| RESET error
| CLR error"""
p[0] = node('error', val="Function call error", no=p.lineno(1))
sys.stderr.write(f'>>> Procedure call error\n')
def p_if(p):
"""if : IF logic_expression NEWLINE statements_group NEWLINE ELSE statements_group"""
p[0] = node('if',
ch={
'condition': p[2],
'body': p[4],
'else': p[7]
},
no=p.lineno(1))
def build_file_tree(rootDir):
cPath = rootDir.getfpath() + rootDir.getdata()
cList = os.listdir(cPath)
cPath += "/"
nodeList = []
for item in cList:
# pdb.set_trace()
if isgit(item):
continue
if os.path.isfile(cPath + item):
cfile = node(item)
cfile.setfpath(cPath)
rootDir.add(cfile)
else:
nextdir = node(item)
nextdir.setfpath(cPath)
build_file_tree(nextdir)
rootDir.add(nextdir)
def search(self, b):
# Initial depth limit
depth_limit = -1
while True:
# Set depth limit
depth_limit += 1
# Create the root node
root = node(None, self.start, 0)
# Initial explored set and frontier
# Frontier: stack
explorered_set = []
frontier = [root]
while len(frontier):
# Expand the deepest (most recent) unexpanded node
# where depth not greater than depth limit
cur_node = frontier.pop()
# Return when path is found
if cur_node.position == self.goal:
return path_list(cur_node)
if cur_node.depth == depth_limit:
continue
if cur_node.position in explorered_set:
continue
possible_moves = cur_node.position.available_moves(b)
self.add_expanded_node()
explorered_set.append(cur_node.position)
for new_pos in possible_moves:
# Create child node and append to parent
child = node(cur_node, new_pos, cur_node.depth+1)
cur_node.add_child(child)
# Set frontier
frontier.append(child)
if len(explorered_set) >= math.pow(b.size, 2):
return []
return []
def SplitData(self, data, features, node):
attribute = features[0]
if len(features) > 1:
o = self.OptimiseInfoGain(data, features)
attribute = o[0]
classes = data[attribute].unique()
columns = features[:]
columns.remove(attribute)
for c in classes:
toSplit = data[attribute] == c
selected_data = data[toSplit]
child = tree.node({"A": attribute, "Class": c})
p = 0
n = 0
for index, row in selected_data.iterrows():
if row["Stream"] == "Yes":
p += 1
else:
n += 1
print ("\n", attribute, c, "\n", selected_data, "\n", p, n, "\n")
if p == 0 or n == 0:
if n == 0:
leaf = tree.Leaf(1, 0)
child.add_node(leaf)
else:
leaf = tree.Leaf(0, 1)
child.add_node(leaf)
node.add_node(child)
elif len (columns) == 0:
total = p + n
leaf = tree.Leaf(p/total, n/total)
child.add_node(leaf)
node.add_node(child)
else:
print ("enter recurse")
self.SplitData(selected_data, columns, child)
node.add_node(child)
print ("exited recurse")
print ("nodes added:", attribute, c)
def get_bst(a):
if len(a) <= 0:
return [None]
res = []
for idx in range(len(a)):
left_trees = get_bst(a[:idx])
right_trees = get_bst(a[idx + 1:])
res += [
node(data=a[idx], left=lt, right=rt) for lt in left_trees
for rt in right_trees
]
return res
def get_binary_trees(num):
if num == 0:
return [None]
cur_res = []
for left_n in range(num):
right_n = num - 1 - left_n
left_trees = get_binary_trees(left_n)
right_trees = get_binary_trees(right_n)
cur_res += [
node(data=0, left=left, right=right) for left in left_trees
for right in right_trees
]
return cur_res
def execute(self):
sink_func = sys.argv[0]
arg_num = sys.argv[1]
#root_node = tree.node(sink_func)
for node_id in self.get_sink(sink_func, arg_num):
print "Now, the sink node id is ", node_id
sink_node = tree.node(node_id)
self.sink_source_tree._head.add(sink_node)
current_path = []
self.get_source(sink_node)
print "ok"
'''current_node.add(node_id)
def SplitData(self, data, features, node):
attribute = features[0]
if len(features) > 1:
optimsed = self.OptimiseInfoGain(data, features)
attribute = optimsed[0]
classes = data[attribute].unique()
columns = features[:]
columns.remove(attribute)
for c in classes:
toSplit = data[attribute] == c
selected_data = data[toSplit]
child = tree.node({"A": attribute, "Class": c})
p = 0
n = 0
for index, row in selected_data.iterrows():
if self.y[index] == "<=50K":
p += 1
else:
n += 1
if p == 0 or n == 0:
if n == 0:
leaf = tree.Leaf(1, 0)
child.add_node(leaf)
else:
leaf = tree.Leaf(0, 1)
child.add_node(leaf)
node.add_node(child)
elif len (columns) == 0:
total = p + n
leaf = tree.Leaf(p/total, n/total)
child.add_node(leaf)
node.add_node(child)
else:
self.SplitData(selected_data, columns, child)
node.add_node(child)
def get_source(self, node):
#source_current_func=get_source_within_func(node_id)
#node.add(node_id)
node_id = node.getdata()
last_source = node_id
if not self.wether_is_over(last_source):
###sources() get the parameter nodes'''
if self.get_type(last_source) == "Argument":
last_source_tmp = self.get_source_within_func(last_source)
last_sources = last_source_tmp
for last_source in last_sources:
node.add(tree.node(last_source))
for source_node in last_sources:
identifier_node = self.get_Identifier_source(source_node)
if identifier_node is not None:
for neighbor_source in identifier_node:
node.add(self.get_source(neighbor_source))
###this should get the arguement nodes'''
elif len(self.get_source_between_func(last_source)) != 0:
last_source_tmp = self.get_source_between_func(last_source)
last_source = last_source_tmp
node.add(last_source)
for source_node in last_source:
identifier_node = self.get_Identifier_source(source_node)
if identifier_node is not None:
for neighbor_source in identifier_node:
node.add(self.get_source(neighbor_source))
###sources() get the IdentifierDeclStatement nodes'''
elif len(self.get_source_of_IdentifierDeclStatement(
last_source)) != 0:
last_source_tmp = self.get_source_of_IdentifierDeclStatement(
last_source)
last_source = last_source_tmp
node.add(last_source)
for source_node in last_source:
identifier_node = self.get_Identifier_source(source_node)
if identifier_node is not None:
for neighbor_source in identifier_node:
node.add(self.get_source(neighbor_source))
def add_children_from_MyNode(tree_file):
# add children
tree = np.load(tree_file, allow_pickle=True, encoding='latin1')
# a new tree with a simplified structure
Tree = []
# read the npy file and put them in MyNode
for i in range(len(tree)):
node_ = tree[i]
parent = node_.parentID
ID = i
Tree.append(node(ID, parent, [], False))
# update the children of its parent
if parent != -1:
Tree[parent].children.append(ID)
# identify the leaves
for i in range(len(Tree)):
if len(Tree[i].children) == 0:
Tree[i].is_leaf = True
return Tree
import tree
dict = {}
def vertical_sum(root, distance):
if (not root):
return
if (distance in dict):
dict[distance] += root.data
else:
dict[distance] = root.data
vertical_sum(root.left, distance - 1)
vertical_sum(root.right, distance + 1)
bst = tree.Tree()
bst.root = tree.node(5)
bst.root.left = tree.node(2)
bst.root.right = tree.node(3)
bst.root.left.left = tree.node(1)
bst.root.left.right = tree.node(7)
bst.root.right.left = tree.node(6)
vertical_sum(bst.root, 0)
for k in sorted(dict.keys()):
print(dict[k], end=' ')
print()
