def main():
data, prune_data, test_data = load_data()
node = create_node(data, feature_list, None, None, 0)
# import pickle
# f=open("node.serize","wb")
# pickle.dump(node,f)
# f.close()
# f=open("node.serize","rb")
# node=pickle.load(f)
train_lable = nm.array(data[lable])
_lable = []
del data[lable]
for _, i in data.iterrows():
l, p = node(i, 1, 0)
_lable.append(l)
train_accuracy = nm.sum(nm.equal(nm.array(_lable),
train_lable)) / len(train_lable)
test_lable = nm.array(test_data[lable])
_lable = []
del test_data[lable]
for _, i in test_data.iterrows():
l, p = node(i, 1, 0)
_lable.append(l)
print(_lable)
test_accuracy = nm.sum(nm.equal(nm.array(_lable),
test_lable)) / len(test_lable)
print(
"before prune : train data accuracy:{} | test data accuracy:{}".format(
train_accuracy, test_accuracy))
node.prune(prune_data)
_lable = []
for _, i in data.iterrows():
l, p = node(i, 1, 0)
_lable.append(l)
train_accuracy = nm.sum(nm.equal(nm.array(_lable),
train_lable)) / len(train_lable)
_lable = []
for _, i in test_data.iterrows():
l, p = node(i, 1, 0)
_lable.append(l)
print(_lable)
test_accuracy = nm.sum(nm.equal(nm.array(_lable),
test_lable)) / len(test_lable)
print(
"after prune : train data accuracy:{} | test data accuracy:{}".format(
train_accuracy, test_accuracy))
def test_example(self):
(d, s, b) = make_variables("d[1, 0, 15], s[1,0,15], b[1, 0, 15]")
chan = node("chan", pois, [d, s+b])
(b0, sigma_b) = make_variables("b0[5,0,10], sigma_b[1,0,3]")
b_constraint = node("b_constraint", gauss, [b0, b, sigma_b])
model = chan*b_constraint
print "model val: ", model()
def tonode(g):
child = []
for i, c in enumerate(g['children']):
child.append(node(c['name'], c['children']))
child[i].val = c['val']
n = node("root", child)
n.val = g['val']
return n
def make_tree(filename="sample.123.321.dump.gz"):
#Print statistics at the end of the program
printstat = False
stat = statistics(1234)
#Create binary tree root
root = node(socket.inet_aton("0.0.0.0"), 0, [], None, False, 0)
dump = Parser(filename)
loop = True
#Loop over the input file, reading one line at a time.
while loop:
try:
line = dump.next()
except:
print "EOF"
break
#Parsing dumps
if line[0] == 'D':
for entry in line[3]:
fromSet = False
time = entry[-1]
act = 'A' #Action: A|W
revoked = None
mask = line[2]
prefix = int2ip(line[1])
if act == "W":
revoked = 'revoked'
else:
revoked = None
origin = parseASpath(entry, stat)
new_node = node(socket.inet_aton(prefix), mask, origin, revoked, fromSet, time)
addAction(act, root, new_node, stat)
#Parsing updates
elif line[0] == 'U':
for entry in line[3]:
time = entry[-1]
fromSet = False
act = entry[0] #Action: A|W
revoked = None
mask = entry[2]
prefix = int2ip(entry[1])
if act == "W":
revoked = 0
else:
revoked = None
origin = parseASpath(entry, stat)
new_node = node(socket.inet_aton(prefix), mask, origin, revoked, fromSet, time)
addAction(act,root, new_node, stat)
#Unknown type (neither dump nor update)
else:
print "Unknown message type " + line[0]
return root
def addEpsilonStates(self, initialNode):
tempNode = initialNode
tempNode.init = False
newInitNode = node("initial", True, False)
newInitNode.directionsDict['$'] = [tempNode]
newFinalNode = node("final", False, True)
for x in self.arr_nodos:
if x.final:
x.directionsDict['$'] = [newFinalNode]
x.final = False
self.arr_nodos.extend([newInitNode, newFinalNode])
def setUp(self):
(x0, mu0, sigma0) = make_variables("x0[.2,-6,6], mu0[0,-5,5], sigma0[1,0,3]")
mass0 = node("mass0", gauss, {'x':x0, 'mu':mu0, 'sigma':sigma0})
(x1, mu1, sigma1) = make_variables("x1[1.2,-6,6], mu1[1,-5,5], sigma1[2,0,3]")
mass1 = node("mass1", gauss, {'x':x1, 'mu':mu1, 'sigma':sigma1})
inv_mass = node("inv_mass", invariant_mass, {"a": mass0, "b":mass1})
self.vars = (x0, mu0, sigma0, x1, mu1, sigma1)
self.nodes = (inv_mass, mass0, mass1)
def construct(self): queue = Queue.Queue() if self.root is None: self.root = node(self.data, self.type) queue.put(self.root) while queue.empty() is False: cur_node = queue.get() if cur_node.is_leaf is True: continue for child in cur_node.children.keys(): cur_node.connection[child] = node(cur_node.children[child], self.type) queue.put(cur_node.connection[child])
def to_cnf(root):
if root.kind in ['^', 'v']:
if root.children[0] not in ['^', 'v']:
atom, conn = root.children
else:
conn, atom = root.children
# one child has to be a connective and the other a non-connetive
if atom.kind not in ['^', 'v'] and conn.kind in ['^', 'v'] and conn.kind != root.kind:
child1 = node(root.kind, atom, conn.children[0])
child2 = node(root.kind, atom.clone(), conn.children[1])
root.children = [child1, child2]
root.kind = conn.kind
for c in root.children:
to_cnf(c)
def _insert(self, value, cur_node):
if value < cur_node.value:
if cur_node.left_child == None:
cur_node.left_child == node(value)
cur_node.left_child.parent = cur_node
else:
self._insert(value, cur_node.left_child)
elif value > cur_node.value:
if cur_node.right_child == None:
cur_node.right_child = node(value)
cur_node.right_child.parent = cur_node
else:
self._insert(value, cur_node.right_child)
else:
print("Value already in tree!")
def Dictionary_into_Node(Node_Dic):
Root_List = []
#going backwards it iterates through the dictionary
for i in reversed(range(0, len(Node_Dic))):
#If the current Dictionary has no child it will create a node and append it
if Node_Dic[i]['children'] == []:
Root_List.append(node(Node_Dic[i]['name']))
Root_List[len(Root_List) - 1].val = Node_Dic[i]['val']
else:
#If it does have a child it will look for its child in the Root list dictionary and append them in a new node
Root_List.append(
node(Node_Dic[i]['name'],
FatherChildren(Root_List, Node_Dic[i]['children'])))
Root_List[len(Root_List) - 1].val = Node_Dic[i]['val']
#Will return the last node in the List which is the root of the tree
return Root_List[len(Root_List) - 1]
def __init__(self,
data,
data_type,
y,
y_type,
n_classes,
F=1,
min_leaf_size=1,
n_retry=1,
f_num="VR",
f_cat="IG"):
self.data = data
self.data_type = data_type
self.y = y
self.y_type = y_type
self.n_classes = n_classes
self.min_leaf_size = min_leaf_size
self.F = F
self.options = {
"VR": self.VR,
"IG": self.IG,
"GINI": self.GINI,
"TEST": self.TEST
}
self.f_num = self.options[f_num]
self.f_cat = self.options[f_cat]
self.n_retry = n_retry
split_feature, split_number, data_left_idx, data_right_idx = self.find_split(
np.array(list(range(len(data)))))
self.root = node(data_type[split_feature])
self.root.split_value = split_number
self.root.split_feature = split_feature
self.grow_tree(self.root, data_left_idx, data_right_idx)
def dictionary_to_object(serialized_graph): # initialize root node to None root_node = None # iterate through all nodes in the dictionary for each_node in serialized_graph: # create node objects for each node in the dictionary # and assign a new dictionary item in the existing # dictionary to hold the object serialized_graph[each_node]['node_object'] = node(serialized_graph[each_node]['name']) # get the value of node from the dictionary serialized_graph[each_node]['node_object'].val = serialized_graph[each_node]['value'] # empty list of childrem serialized_graph[each_node]['node_object'].children = [] # if the level of this node is 0, then assign root node to the current node object if serialized_graph[each_node]['level'] == 0: root_node = serialized_graph[each_node]['node_object'] # after creating all nodes, # iterate through each node to assign the # children node object pointer to the correct parent for each_node in serialized_graph: # iterate through all children for each_child in serialized_graph[each_node]['children']: serialized_graph[each_node]['node_object'].children.append(serialized_graph[each_child]['node_object']) # return the root node return root_node
def findLabel(self, treestr, i):
tlabel = ''
while (i < len(treestr) and treestr[i] !='(' and treestr[i] != ',' and treestr[i] != ')'):
tlabel += treestr[i]
i += 1
newNode = node(tlabel)
return newNode, i
def fill_network(
self, num_nodes): #quickly fill network and randomly place nodes
for i in range(num_nodes): #create and add nodes to network
ide = str(i)
node_temp = node(ide)
node_temp.load_pkl()
self.add_node(node_temp)
def insertNode(self, n):
#Add a dummy element to the list becuase list index must start at 1
#for heap operations to work
if len(self.nodes) == 0:
self.nodes.append(node(-1, -1))
self.nodes.append(n)
self.index[n.value] = len(self.nodes) - 1
self.bubbleUp(n)
def jsond(data):
obj = ast.literal_eval(data)
print(obj)
# return node("Root")
children = []
for child in obj['children']:
children.append(jsond(child))
return node(obj['name'], children, obj['val'])
def _skolemize(n, fn_args = [], skolems = {}):
if n.kind == 'A':
fn_args.append(n.name)
elif n.kind == 'E':
children = [node('var', a) for a in fn_args]
skolems[n.name] = node('fn', avail.pop(), *children)
elif n.kind == 'var':
if n.name in skolems:
n.consume(skolems[n.name].clone())
for c in n.children:
_skolemize(c, fn_args, skolems)
if n.kind == 'A':
fn_args.pop()
elif n.kind == 'E':
del skolems[n.name]
n.consume_child()
def fill_network(self):
files = os.listdir(DataMule_path)
nodeIDs = [int(self.get_ID(file)) for file in files]
nodeIDs.sort()
for i in range(len(nodeIDs)):
node_ID = nodeIDs[i]
node_curr = node(node_ID)
self.add_node(node_curr)
def addNode(self, infoList):
id, x, y, z = infoList
id = int(id.split(",")[0].strip())
x = float(x.split(",")[0].strip())
y = float(y.split(",")[0].strip())
z = float(z.split(",")[0].strip())
newNode = node(id, x, y, z)
self.nodeMap[id] = newNode
self.nodes += 1
def buildCFPTree(self, items, routeList):
#建立头表
for item in items:
htnodeTmp = node(item[0], item[1])
self.headTable.append(htnodeTmp)
#建树
for routeNode in routeList:
self.insertTran(routeNode, self.root)
def insert(self,path,data):
""""""
cur_node = self._head
for step in path:
if cur.search_children(step)==None:
return False
else:
cur=cur.search_children(step)
cur.add(node(data))
return True
def buildGraphRecursive(root, children):
for child in children:
#print(child) does indeed print out child
#if (child["children"] != ""):
#buildGraphRecursive(child, child["children"])
tempChild = node(child["name"]) #valid node is created out of this
#root.children = node(child["name"]) #returns reference to object addy???
#print(child) #dictionary type
#print(root.name) #no error when grabbing fields
print(tempChild.name)
def JSONToGraph(jsonString):
jsonArr = jsonString.split('\n')
name = jsonArr[0].split(':')[1]
val = jsonArr[1].split(':')[1]
children = []
for c in jsonString[jsonString.find("{") + 1:].split(',')[:-1]:
children.append(JSONToGraph(c))
graph = node(name, children)
graph.val = int(val)
return graph
def run(self):
while (not self.stop_cond.is_set()):
packet = self.client.rxpacket()
if packet != None:
node1 = node(packet, 0, None)
self.LList.addNode(node1)
else:
print "no packet"
print "Sniffing Terminated"
return
def obtainDict(self, DictRoot): #Creates all necessary steps for dict.
global treeToUse
global JSONDecryptedTree
treeToUse = json.loads(DictRoot)
for x, y in treeToUse.items(
): #Iterates across tree objects and adds it to a variable.
temp = json.loads(y)
treeToUse[x] = node(temp[list(temp.keys())[0]],
temp[list(temp.keys())[1]])
JSONDecryptedTree = parseTree(treeToUse, JSONDecryptedTree)
JSONDecryptedTree.show(0)
def increment(self, graph):
print("Received from client:", graph)
root_children = [] # For the children of the root
root = list(graph)[0] # Get the name of the root
root_val = graph[root][len(graph[root]) -
1] # Get the value of the root
del graph[root][len(graph[root]) - 1] # Delete the root value
for child in graph[root]: # Traverse every child in the graph
if not root_children: # If the graph is empty add the child
tmp_child = node(child[0], child[1]) # Create the node
tmp_child.val = child[2] # Assign its value
root_children.append(tmp_child) # Add it to the list
else:
in_list = False # Flag to check if node already on the list
for index in range(len(root_children)
): # Check the list to see i already there
if child[0] == root_children[index].name: # If there
in_list = True # Set flag
root_children.append(
root_children[index]
) # Append the one already in the list again
break
if not in_list: # If not in the list
tmp_child = node(child[0], child[1]) # Create the node
tmp_child.val = child[2] # Assign its value
root_children.append(tmp_child) # Add it to the list
root = node(root, root_children) # Generate the graph
root.val = root_val # Assign the value of the root
increment(root) # Increment the graph
graph = {root.name: []} # Start the dictionary to send to the client
for child in root.children: # Populate the dictionary with the children
graph[root.name].append([child.name, child.children, child.val])
graph[root.name].append(root.val) # Append the new value of the root
print("Sending to client:", graph, "\n")
return graph # Send it to the client
def unflatten(jFile):
with open(jFile) as lFile:
j = json.load(lFile)
lFile.close()
jlist = j["children"]
leaf1 = node(jlist[0]["name"])
leaf1.val = jlist[0]["val"]
leaf2 = node(jlist[1]["name"])
leaf1.val = jlist[1]["val"]
leaf3 = node(jlist[2]["name"])
leaf1.val = jlist[2]["val"]
root = node(j["name"], [leaf1, leaf2, leaf3])
root.val = j["val"]
root.show()
return root
def run(self):
while(not self.stop_cond.is_set()):
packet = self.client.rxpacket()
if packet != None:
node1 = node(packet,0,None)
self.LList.addNode(node1)
else:
print "no packet"
print "Sniffing Terminated"
return
def __init__(self, data, label, type_list, list_of_interpreter, max_split,
minimal_data_size):
self.data = data
self.type_list = type_list
self.list_of_interpreter = list_of_interpreter
self.max_split = max_split
self.label = label
self.root = node(data, label)
self.minimal_data_size = minimal_data_size
self.leaves = [self.root]
self.nodes = [self.root]
def cpb4(self, htNode):
routeList = []
if htNode.children:
for nodeTmp in htNode.children:
treeNode = nodeTmp
childNode = node()
currentNode = node()
flag = 0
while treeNode.parent.count != -1:
if flag == 0:
currentNode = node(treeNode.parent.item, treeNode.count)
treeNode = treeNode.parent
flag = 1
else:
childNode = currentNode
currentNode = node(treeNode.parent.item, currentNode.count)
childNode.parent = currentNode
currentNode.children.append(childNode)
#根据路径向上搜索
treeNode = treeNode.parent
routeList.append(currentNode)
return routeList
def buildFPtree(self, items, transactions):
#建立头表
for item in items:
htnodeTmp = node(item[0], item[1][0])
self.headTable.append(htnodeTmp)
#建树
for tran in transactions:
count = 0
tranRoot = node()
parentNode = node()
for item in tran:
if count == 0:
nodeTmp = node(item, 1)
tranRoot = nodeTmp
count = 1
else:
nodeTmp = node(item, 1)
nodeTmp.parent = parentNode
parentNode.children.append(nodeTmp)
parentNode = nodeTmp
self.insertTran(tranRoot, self.root)
def buildJson(Str):
glist = json.loads(Str)
gkeys = list(glist.keys())
nodes = {}
for i in range(len(glist)):
nodes[gkeys[i]] = node(gkeys[i])
for i in gkeys:
nodes[i].val = glist[i]["val"]
temp = glist[i]["children"].values()
nodes[i].children = []
for j in temp:
nodes[i].children.append(nodes[j])
return nodes["root"]
def helpInsert(self, x, root):
# if tree is empty, make node x the root of the tree.
if root is None:
root = node(x.getKey(), None, None)
return x
# if node's key is smaller than the root's key.
if x.getKey() < root.getKey():
# Recurse until node x is the root of
# the left subtree.
if self.helpInsert(x, root.getLeft()) == x:
# if node x has a smaller rank than the
# root of the subtree, set node x to
# be it's left child.
if x.getRank() < root.getRank():
root.setLeft(x)
# if node x has a larger rank than the
# root of the subtree, set node x as the new root
# of the subtree, and make the old root x's right
# child
else:
root.setLeft(x.getRight())
x.setRight(root)
return x
# if node's key is larger than or equal to the root's key.
else:
# Recurse until node x is the root of
# the right subtree.
if self.helpInsert(x, root.getRight()) == x:
# if node x has a smaller or equal to the
# rank of the root of the subtree, set node x to
# be it's right child.
if x.getRank() <= root.getRank():
root.setRight(x)
# if node x has a larger rank than the
# root of the subtree, set node x as the new root
# of the subtree, and make the old root x's left
# child
else:
root.setRight(x.getLeft())
x.setLeft(root)
return x
return root
def updateNode(self, nodes, element):
myList = []
for current in nodes:
if current.getId() in self.nodeTracker:
self.nodes += 1
id = current.getId()
current = node(self.nodes, current.x, current.y, current.z)
self.nodeMap[self.nodes] = current
element.updateNode(id, current)
else:
self.nodeTracker[current.getId()] = []
myList.append(current.getId())
return myList
def test_3d_int(self):
(x0, mu0, sigma0, x1, mu1, sigma1) = self.vars
(inv_mass, mass0, mass1) = self.nodes
(x2, mu2, sigma2) = make_variables("x2[2.2,-6,6], mu2[2,-8,8], sigma2[2,0,3]")
mass2 = node("mass2", gauss, {'x':x2, 'mu':mu2, 'sigma':sigma2})
prod = mass0*mass1*mass2
#integral = inv_mass.integral(x0, x1)
integral = prod.integral(x0, x1, x2)
self.assertAlmostEqual(integral, 1.0, 1)
print "Integral over x0, x1, and x2: ", integral
def runaStar(length, numColors, gridSpace, startingPoints, endingPoints):
color = 0
startingNodes = []
solutions = []
stackTrace = []
while(color < numColors):
xcoord = startingPoints[color][0]
ycoord = startingPoints[color][1]
ID = str(ycoord) + " " + str(xcoord)
newNode = node(None, None, xcoord, ycoord, gridSpace[xcoord][ycoord], 0, ID)
startingNodes.append(newNode)
color += 1
color = 0
while(color < numColors):
xcoord = endingPoints[color][0]
ycoord = endingPoints[color][1]
ID = str(ycoord) + " " + str(xcoord)
newNode = node(None, None, xcoord, ycoord, gridSpace[xcoord][ycoord], 0, ID)
startingNodes.append(newNode)
color += 1
return aStar(startingNodes, gridSpace, length, numColors)
def toGraph(self,dictionary):
root = node("root",[])
for key in dictionary:
if key == 'name':
root.name= dictionary[key]
#print "root name is:" ,root.name
elif key=='val':
#root.val= dictionary[key]
print "root value is:", root.val
elif key=='children':
#print "Children are:", root.children
leaf1 = node("leaf1")
leaf2 = node("leaf2")
for x in dictionary[key]:
root.children = leafx=node("x")
for y in x:
if x["name"]=='leaf1':
leaf1.name = x["name"]
leaf1.val = x["val"]
leaf1.children=x["children"]
# print "leaf 1 name is:" , leaf1.name
elif x["name"]=='leaf2':
leaf2.name = x["name"]
leaf2.val = x["val"]
leaf2.children=x["children"]
#print "leaf 2 name is:" , leaf2.name
root = node("root",[leaf1,leaf1,leaf2])
nodeName = []
increment(root,nodeName)
dictionary = {"name": None, "val": None, "children": []}
dictionary = toDictionary(root,dictionary)
return dictionary
def get_nodes(self):
startNode = self.repository.repo[self.get_node()]
queue = []
queue.append(startNode)
nodes = {}
c = 0
while len(queue) != 0:
currentNode = queue.pop()
if not currentNode.hex() in nodes:
nodes[currentNode.hex()] = currentNode
if currentNode.__nonzero__():
if currentNode.branch() == self.name:
for parentNode in currentNode.parents():
queue.append(parentNode)
return [node(nodes[b]) for b in nodes]
def createNodes(dict):
nodeList=[]
#dfList(pd.DataFrame(dict))
for ip in dict.keys():
pkts=pd.DataFrame(dict[ip]['pkts'])
hop=64-(int(pkts[0:1]["ttl"]))
pkts = pkts.drop(['ttl'], axis=1)
pkts=pkts.rename(columns={"pkt":"seq"})
#print(type(pkts[0:1]["ttl"]))
#print(pkts[0:1]["ttl"])
n=node(ip,hop,pkts)
nodeList.append(n)
return nodeList
def _instantiate_nodes(self):
#generate NUMBER_OF_NODES nodes
for i in range(NUMBER_OF_NODES):
new_node = node(master_addr=self, [],
0.5,
self.genesis_block,
i + 8000)
self.nodes.append(new_node)
#Assign each node some neighbors
for i, node in enumerate(self.nodes):
for x in range(random.randint(3, 6)):
randint = random.randint(0, NUMBER_OF_NODES)
while randint == i:
randint = random.randint(0, NUMBER_OF_NODES)
node.neighbors.append(self.nodes[randint])
def buildFromJson(jStr):
myDict = json.loads(jStr)
myKeys = list(myDict.keys())
# Create Nodes
nodes = {}
for i in range(len(myDict)):
nodes[myKeys[i]] = node(myKeys[i])
# Set children
for i in myKeys:
nodes[i].val = myDict[i]["val"]
auxKeys = myDict[i]["children"].values()
nodes[i].children = []
for auxChild in auxKeys:
nodes[i].children.append(nodes[auxChild])
return nodes["root"]
def make_tree(input_list, out_dir):
save_dir = out_dir + "/"
origin_as = {}
path_as = {}
tree = node()
count = 0
save_nr = 1
i = 0
for filename in input_list:
print i + 1, filename
i += 1
read_file(filename, tree, origin_as, path_as)
count += 1
if count == SAVE_INTERVAL:
#### SAVING FILES ####
filename_tree = "pickled_prefix_" + str(save_nr)
filename_path = "pickled_path_" + str(save_nr)
filename_origin = "pickled_origin_" + str(save_nr)
print "saving prefix tree as", save_dir + filename_tree
pickle.dump(tree, open(save_dir + filename_tree, "wb"))
print "saving AS origins as", save_dir + filename_origin
pickle.dump(origin_as, open(save_dir + filename_origin, "wb"))
print "saving AS paths as", save_ddir + filename_path
pickle.dump(path_as, open(save_dir + filename_path, "wb"))
count = 0
save_nr += 1
#### SAVING FILES ####
filename_tree = "PrefixTree.pickle"
filename_path = "ASpaths.pickle"
filename_origin = "ASorigins.pickle"
print "saving prefix tree as", save_dir + filename_tree
pickle.dump(tree, open(save_dir + filename_tree, "wb"))
print "saving AS origins as", save_dir + filename_origin
pickle.dump(origin_as, open(save_dir + filename_origin, "wb"))
print "saving AS paths as", save_dir + filename_path
pickle.dump(path_as, open(save_dir + filename_path, "wb"))
def parse(self, lev_file):
# Read .lev file into an array of lines
f = open(lev_file)
lines = f.readlines()
f.close()
# find nodes count
nodecount = int(lines[0]) - 1
# Make a list of nodes
nodes = [node() for i in range(nodecount)]
# Parse nodes
if len(lines) < nodecount + 2:
print "Invalid file format. Expecting ", nodecount + 2, " lines."
else:
for i in range(nodecount):
nodes[i] = self.parseLineToNode(lines[i + 2])
return nodes
def test_vals(self):
# Test a gaussian pdf
(x, mu, sigma) = make_variables("x[.2,-5,5], mu[0,-5,5], sigma[1,0,3]")
mass = node("mass", gauss, {'x':x, 'mu':mu, 'sigma':sigma})
my_pdf = pdf(mass, data=['x'])
# Evaluate the pdf
mu.val = 0
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x.val, mu.val, sigma.val, val)
self.assertTrue( abs(val - 0.39104269) < .01 )
mu.val = 2
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x.val, mu.val, sigma.val, val)
self.assertTrue( abs(val - 0.07895016) < .01 )
x.val = 1
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x.val, mu.val, sigma.val, val)
self.assertTrue( abs(val - 0.24197072) < .01 )
def normalize(root, restrict_to = None):
if restrict_to is not None and root.kind != restrict_to: pass
# a <=> b :::: a ==> b ^ b ==> a
elif root.kind == '<=>':
root.kind = '^'
root2 = root.clone()
child1 = node('==>', *root.children)
child2 = node('==>', *list(reversed(root2.children)))
root.children = [child1, child2]
# a ==> b :::: ~a v b
elif root.kind == '==>':
root.kind = 'v'
root.children[0] = node('~', root.children[0])
# push the nots inwards
elif root.kind == '~':
child = root.children[0]
# ~~a :::: a
if child.kind == '~':
child.consume_child()
root.consume_child()
# ~(a ^ b) :::: (~a v ~b)
elif child.kind == '^':
root.kind = 'v'
root.children = [node('~', c) for c in child.children]
# ~(a v b) :::: (~a ^ ~b)
elif child.kind == 'v':
root.kind = '^'
root.children = [node('~', c) for c in child.children]
# ~Ax[f(x)] :::: Ex[~f(x)]
elif child.kind == 'A':
root.kind = 'E'
root.name = child.name
root.children = [node('~', c) for c in child.children]
# ~Ex[f(x)] :::: Ax[~f(x)]
elif child.kind == 'E':
root.kind = 'A'
root.name = child.name
root.children = [node('~', c) for c in child.children]
for c in root.children:
normalize(c, restrict_to)
def test_pdf(self):
# Make a simple pdf for integration and normalization testing
(x0, mu0, sigma0) = make_variables("x0[.2,-5,5], mu0[0,-5,5], sigma0[1,0,3]")
mass0 = node("mass0", gauss, {'x':x0, 'mu':mu0, 'sigma':sigma0})
my_pdf = pdf(mass0, data=['x0'])
# Evaluate the pdf
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x0.val, mu0.val, sigma0.val, val)
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x0.val, mu0.val, sigma0.val, val)
# 1-d Fitting
my_pdf.logging.setLevel(logging.DEBUG)
my_pdf.fitTo( data=1, params_to_fit=["mu0"])
print "Fitted pdf to x=1: mu=%s x=%s" % (mu0.val, x0.val)
# Get a 2-d function and make a pdf
inv_mass = make_node()
my_pdf = pdf(inv_mass, data=['x0', 'x1'])
# By Variable
x0 = inv_mass.var('x0')
x1 = inv_mass.var('x1')
my_pdf = pdf(inv_mass, data=[x0, x1])
print "Params: ", [param.name for param in my_pdf._params]
print "Data: ", [param.name for param in my_pdf._data]
print "x0 in pdf: ", my_pdf.var('x0'), my_pdf.var('x0').val
# Evaluate the pdf
val = my_pdf()
print "x=%s, mu=%s, sigma=%s, val=%s" % (x0.val, mu0.val, sigma0.val, val)
my_pdf.fitTo( data={x0:1, x1:1.2}, params_to_fit=["mu0"])
def parseLineToNode(self, line):
params = line.split(" ")
n = node()
n.id = int(params[0])
n.gatetype = int(params[1])
n.level = int(params[2])
n.fanins = int(params[3])
# cc0, cc1 end index
cc0_end_index = n.fanins + 4
cc1_end_index = 2 * n.fanins + 4
n_fanouts_index = cc1_end_index
# Adding cc0, cc1 lists
for i in range(4, cc0_end_index):
n.cc0_input_order.append(int(params[i]))
for i in range(cc0_end_index, cc1_end_index):
n.cc1_input_order.append(int(params[i]))
# fanouts value
n.fanouts = int(params[n_fanouts_index])
# co_output index
co_end_index = n_fanouts_index + 1 + n.fanouts
# Adding co_output list
for i in range(n_fanouts_index + 1, co_end_index):
n.co_output_order.append(int(params[i]))
# Setting remaining params - co, po, cc0, cc1
n.co = int(params[co_end_index])
n.po = params[co_end_index + 1]
n.cc0 = int(params[co_end_index + 2])
n.cc1 = int(params[co_end_index + 3])
return n
def main():
#get 8 puzzle
print("Enter an 8puzzle")
r1 = input()
r2 = input()
r3 = input()
#split input into seperate numbers
r1 = r1.split()
r2 = r2.split()
r3 = r3.split()
r1 = r1 + r2 + r3
#make all into int
r1 = list(map(int, r1))
r1 = node(r1)
print (""""Enter the type of search
(0) Uniform cost
(1) A* with misplaced tile heuristic
(2) A* with manhattan distance
""")
s = input()
if search(r1, int(s)):
print("solution found")
else:
print("no solution")
def nodemaker(n):
a=[]
for x in range(n):
y= node(x,x,x)
a.append(y)
return a
E('y',
infix(
fn('Q', var('y')),
'^',
fn('R', var('y'), var('x'))))))))
tests.append(
E('x',
infix(
fn('P', var('x')),
'^',
A('x',
infix(
fn('Q', var('x')),
'==>',
node('~', fn('P', var('x'))))))))
tests.append(
A('x',
infix(
fn('P', var('x')),
'<=>',
infix(
fn('Q', var('x')),
'^',
E('y',
infix(
fn('Q', var('y')),
'^',
fn('R', var('y'), var('x'))))))))
def __init__(self, root_data=None): self.root = node(root_data) self.end = self.root
# -*- coding: utf-8 -*-
from ecdsa import SigningKey
from transaction import *
from node import *
"""
privatekey = SigningKey.generate()
publickey = privatekey.get_verifying_key()
message = "Reshma" + "Thomas"
signature = privatekey.sign(message)
#print "Signature is", signature
assert publickey.verify(signature, message)
"""
# checked signing,verification problem
filename = "newtrans.txt"
newnode = node()
# newtrans = filetotrans(filename)
# transtofile(newtrans, "new.txt")
signtrans(newnode, filename)
T = filetotrans("signedtrans.txt")
# verifying the signature(Not sure if it will work!)
transstr = str(T.incount) + str(T.outcount)
for i in range(T.incount):
inliststr = str(T.inlist[i].hash) + str(T.inlist[i].n) + str(T.inlist[i].pub)
assert newnode.publickey.verify(T.inlist[i].sign, inliststr)
from node import *
from endNode import *
from protocolDecisionTreeConstruct import *
t = node("t")
b = node("b")
h = node("h")
hi = node("hi")
hs= node("hs")
ha=node("ha")
end = endNode()
test = protocolDecisionTreeConstruct()
test.addNewNode(t,"start")
test.addDecisionNode(ha,hs,"t")
node = test.createNode("his")
test.setFieldInfo(False,False,True,False,False,"t","hi")
test1 = test.getFieldInfo(False,False,True,False,False,"t")
test = test.createList()
print test
print node.name
def add(self, data): self.end.set_next(node(data)) self.end = self.end.get_next()
def __init__(self):
self.root = node('root', -1)
self.headTable = []
import random from node import * from m1m3 import * from SearchSubC import * from SearchSubS import * import mr,rp1,rp2,rp3 import cplex N=50 C=3 S=2 U=S H=C for i in xrange(I_size): X=node() X.index=i X.E=random.uniform(0.3,0.5) #X.E=cplex.infinity X.R=10 X.x=random.randrange(0,N) X.y=random.randrange(0,N) I.append(X) I[i].k_index=-1 I[i].j_index=-1 for j in xrange(J_size): J.append(I[j*3]) I[j*3].j_index=j J[j].j_index=j
def createNode(self,name):
newNode = node(name)
return newNode
def load_graph(self, file):
"""The format of the file must be:
nodeX -- nodeY -- rtt -- bwXY -- bwYX
nodeX -- nodeZ -- rtt -- bwXZ -- bwZX
...
The "-- weightXY -- weightYX" part is optional.
All the lines of the file which aren't in this form are
ignored. In other words, you can use Graphviz (.dot) file.
"""
f=open(file)
for l in f:
w=re.split(' *-- *', l.strip())
if len(w) == 1:
continue
if len(w)==7:
rtt=float(w[2])
bwXY=float(w[3])
bwYX=float(w[4])
dpx=float(w[5])
dpy=float(w[6])
elif len(w) == 2:
rtt=G.DEFAULT_RTT
bwXY=G.DEFAULT_BW
bwYX=G.DEFAULT_BW
dpx=G.DEFAULT_DP
dpy=G.DEFAULT_DP
else:
print "ERROR: The format of the file must be: \n nodeX -- nodeY -- rtt -- bwXY -- bwYX -- dpx -- dpy \n nodeX -- nodeZ -- rtt -- bwXZ -- bwZX -- dpx -- dpz\n ..."
sys.exit()
first_n=int(w[0])
second_n=int(w[1])
#pdb.set_trace()
rem_first=rem_t(rtt,bwXY,bwYX,0) #create a rem per each direction of the link; the dp will assigned later per each node
rem_second=rem_t(rtt,bwYX,bwXY,0) #create a rem per each direction of the link; the dp will assigned later per each node
if G.whole_network.has_key(first_n): #the nodeX already exist
G.whole_network[first_n].new_link(second_n,rem_first) #add to nodeX the link for the nodeY
else:
nodex = node(first_n, second_n,rem_first) #create an istance of the nodeX
if G.DP_ENHANCEMENT: #assign a death probability
if nodex.dp==0:
nodex.dp=dpx
G.whole_network[first_n]=nodex
nodex.hook()
if G.whole_network.has_key(second_n): #the nodeY already exist
G.whole_network[second_n].new_link(first_n,rem_second) #add to nodeY the link for the nodeX
else:
nodey = node(second_n, first_n,rem_second) #create an istance of the nodex
if G.DP_ENHANCEMENT: #assign a death probability
if nodey.dp==0:
nodey.dp=dpy
G.whole_network[second_n]=nodey
nodey.hook()
def merge_dir(data_dir, out_dir, base_dir=None):
global TRAVERSED
###############################
print "\n## MERGING TREES ##"
print "###################\n"
###############################
# create empty tree
root = node()
TRAVERSED = 0
paths = set()
# Add base pickles directory to build upon
if base_dir is not None:
for subdir, dirs, files in os.walk(base_dir):
for f in files:
paths.add(subdir)
# Add tmp files for merge
for subdir, dirs, files in os.walk(data_dir):
for f in files:
paths.add(subdir)
count = 0
for path in sorted(paths):
try:
TRAVERSED = 0
count += 1
file_path = os.path.join(path, TREE_NAME)
update_tree = pickle.load(open(file_path, 'rb'))
size = update_tree.size()
print "UPDATE tree " + str(count) + "/" + str(len(paths)) + " '" + os.path.join(path, TREE_NAME) + "' loaded (size=" + str(size) + ")."
add_tree(root, update_tree, size)
print "...new root size=" + str(root.size()) + ".\n"
#os.remove(file_path)
except:
print "Could not read file:",file_path
# save final tree
os.mkdir(out_dir)
root_file = os.path.join(out_dir, 'PrefixTree.pickle')
print "Saving root tree to '" + root_file + "'."
pickle.dump(root, open(root_file, "wb"))
print "...ok!"
root = None
update_tree = None
######################################
print "\n\n## MERGING AS ORIGINS ##"
print "########################\n"
######################################
# create empty dict
asorigins = dict()
count = 0
for path in sorted(paths):
try:
count += 1
file_path = os.path.join(path, AS_ORIGIN_NAME)
update_dict = pickle.load(open(file_path, 'rb'))
print "adding UPDATE dict " + str(count) + "/" + str(len(paths)) + " from " + os.path.basename(os.path.dirname(path)) + " (size=" + str(len(update_dict)) + ")."
asorigins = add_dict(asorigins, update_dict)
print "...new dict size=" + str(len(asorigins)) + ".\n"
#os.remove(file_path)
except:
print "Could not read file:",file_path
# save final dict
dict_file = os.path.join(out_dir, 'ASorigins.pickle')
print "Saving AS origins dict to '" + dict_file + "'."
pickle.dump(asorigins, open(dict_file, "wb"))
print "...ok!"
####################################
print "\n\n## MERGING AS PATHS ##"
print "######################\n"
####################################
# create empty dict
aspaths = dict()
count = 0
for path in sorted(paths):
try:
count += 1
file_path = os.path.join(path, AS_PATH_NAME)
update_dict = pickle.load(open(file_path, 'rb'))
print "adding UPDATE dict " + str(count) + "/" + str(len(paths)) + " from " + os.path.basename(os.path.dirname(path)) + " (size=" + str(len(update_dict)) + ")."
aspaths = add_dict(aspaths, update_dict)
print "...new dict size=" + str(len(aspaths)) + ".\n"
#os.remove(file_path)
except:
print "Could not read file:",file_path
# save final dict
dict_file = os.path.join(out_dir, 'ASpaths.pickle')
print "Saving AS paths dict to '" + dict_file + "'."
pickle.dump(aspaths, open(dict_file, "wb"))
print "...ok!\n"
