diff --git a/gmatch4py/graph.pyx b/gmatch4py/graph.pyx
index 2d3abca2ca09d954cafc9c8512062c85d633c190..43fd7204f2b320ce4a07a235a73da5b0ab1335e5 100644
--- a/gmatch4py/graph.pyx
+++ b/gmatch4py/graph.pyx
@@ -17,128 +17,132 @@ cdef class Graph:
self.is_node_attr=(True if node_attr_key else False)
self.is_edge_attr=(True if edge_attr_key else False)
- if len(G) == 0:
- return
-
- a,b=list(zip(*list(G.nodes(data=True))))
- self.nodes_list,self.attr_nodes=list(a),list(b)
- if G.number_of_edges()>0:
- e1,e2,d=zip(*list(G.edges(data=True)))
- self.attr_edges=list(d)
- self.edges_list=list(zip(e1,e2))
+ if len(G) ==0:
+ self.nodes_list,self.nodes_attr_list,self.nodes_hash,self.nodes_weight,self.attr_nodes=[],[],[],[],[]
+ self.nodes_degree,self.nodes_degree_in,self.nodes_degree_out,self.nodes_degree_weighted,self.nodes_degree_in_weighted,self.nodes_degree_out_weighted=np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.long)
+ self.nodes_idx,self.degree_per_attr,self.degree_per_attr_weighted={},{},{}
+ self.nodes_hash_set=set([])
+
else:
- self.edges_list=[]
- self.attr_edges=[]
+ a,b=list(zip(*list(G.nodes(data=True))))
+ self.nodes_list,self.attr_nodes=list(a),list(b)
+ if G.number_of_edges()>0:
+ e1,e2,d=zip(*list(G.edges(data=True)))
+ self.attr_edges=list(d)
+ self.edges_list=list(zip(e1,e2))
+ else:
+ self.edges_list=[]
+ self.attr_edges=[]
- if self.is_node_attr:
- self.node_attr_key = node_attr_key
- self.nodes_attr_list = [attr_dict[node_attr_key] for attr_dict in self.attr_nodes]
- self.unique_node_attr_vals=set(self.nodes_attr_list)
-
- if self.is_edge_attr:
- self.edge_attr_key = edge_attr_key
- self.edges_attr_list = [attr_dict[edge_attr_key] for attr_dict in self.attr_edges]
- self.unique_edge_attr_vals=set(self.edges_attr_list)
+ if self.is_node_attr:
+ self.node_attr_key = node_attr_key
+ self.nodes_attr_list = [attr_dict[node_attr_key] for attr_dict in self.attr_nodes]
+ self.unique_node_attr_vals=set(self.nodes_attr_list)
+
+ if self.is_edge_attr:
+ self.edge_attr_key = edge_attr_key
+ self.edges_attr_list = [attr_dict[edge_attr_key] for attr_dict in self.attr_edges]
+ self.unique_edge_attr_vals=set(self.edges_attr_list)
- # NODE Information init
- #######################
-
- self.nodes_hash=[self.hash_node_attr(node,self.nodes_attr_list[ix]) if self.is_node_attr else self.hash_node(node) for ix, node in enumerate(self.nodes_list) ]
- self.nodes_hash_set=set(self.nodes_hash)
- self.nodes_idx={node:ix for ix, node in enumerate(self.nodes_list)}
- self.nodes_weight=[attr_dict["weight"] if "weight" in attr_dict else 1 for attr_dict in self.attr_nodes]
- degree_all=[]
- degree_in=[]
- degree_out=[]
+ # NODE Information init
+ #######################
+
+ self.nodes_hash=[self.hash_node_attr(node,self.nodes_attr_list[ix]) if self.is_node_attr else self.hash_node(node) for ix, node in enumerate(self.nodes_list) ]
+ self.nodes_hash_set=set(self.nodes_hash)
+ self.nodes_idx={node:ix for ix, node in enumerate(self.nodes_list)}
+ self.nodes_weight=[attr_dict["weight"] if "weight" in attr_dict else 1 for attr_dict in self.attr_nodes]
+ degree_all=[]
+ degree_in=[]
+ degree_out=[]
- degree_all_weighted=[]
- degree_in_weighted=[]
- degree_out_weighted=[]
- if self.is_edge_attr:
- self.degree_per_attr={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
- self.degree_per_attr_weighted={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
- # Retrieving Degree Information
- self.edges_of_nodes={}
- for n in self.nodes_list:
- self.edges_of_nodes[n]=[self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2) for e1,e2,attr_dict in G.edges(n,data=True)]
- degree_all.append(G.degree(n))
- degree_all_weighted.append(G.degree(n,weight="weight"))
- if self.is_directed:
- degree_in.append(G.in_degree(n))
- degree_in_weighted.append(G.in_degree(n,weight="weight"))
- degree_out.append(G.out_degree(n))
- degree_out_weighted.append(G.out_degree(n))
- else:
- degree_in.append(degree_all[-1])
- degree_in_weighted.append(degree_all_weighted[-1])
- degree_out.append(degree_all[-1])
- degree_out_weighted.append(degree_all_weighted[-1])
+ degree_all_weighted=[]
+ degree_in_weighted=[]
+ degree_out_weighted=[]
if self.is_edge_attr:
+ self.degree_per_attr={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
+ self.degree_per_attr_weighted={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
+ # Retrieving Degree Information
+ self.edges_of_nodes={}
+ for n in self.nodes_list:
+ self.edges_of_nodes[n]=[self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2) for e1,e2,attr_dict in G.edges(n,data=True)]
+ degree_all.append(G.degree(n))
+ degree_all_weighted.append(G.degree(n,weight="weight"))
if self.is_directed:
- in_edge=list(G.in_edges(n,data=True))
- out_edge=list(G.in_edges(n,data=True))
- for n1,n2,attr_dict in in_edge:
- self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
- self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
-
- for n1,n2,attr_dict in out_edge:
- self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
- self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
-
+ degree_in.append(G.in_degree(n))
+ degree_in_weighted.append(G.in_degree(n,weight="weight"))
+ degree_out.append(G.out_degree(n))
+ degree_out_weighted.append(G.out_degree(n))
else:
- edges=G.edges(n,data=True)
- for n1,n2,attr_dict in edges:
- self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
- self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
- self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
- self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
-
+ degree_in.append(degree_all[-1])
+ degree_in_weighted.append(degree_all_weighted[-1])
+ degree_out.append(degree_all[-1])
+ degree_out_weighted.append(degree_all_weighted[-1])
+ if self.is_edge_attr:
+ if self.is_directed:
+ in_edge=list(G.in_edges(n,data=True))
+ out_edge=list(G.in_edges(n,data=True))
+ for n1,n2,attr_dict in in_edge:
+ self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
+ self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+
+ for n1,n2,attr_dict in out_edge:
+ self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
+ self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
- self.nodes_degree=np.array(degree_all)
- self.nodes_degree_in=np.array(degree_in)
- self.nodes_degree_out=np.array(degree_out)
+ else:
+ edges=G.edges(n,data=True)
+ for n1,n2,attr_dict in edges:
+ self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
+ self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
+ self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+ self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+
+
+ self.nodes_degree=np.array(degree_all)
+ self.nodes_degree_in=np.array(degree_in)
+ self.nodes_degree_out=np.array(degree_out)
- self.nodes_degree_weighted=np.array(degree_all_weighted)
- self.nodes_degree_in_weighted=np.array(degree_in_weighted)
- self.nodes_degree_out_weighted=np.array(degree_out_weighted)
+ self.nodes_degree_weighted=np.array(degree_all_weighted)
+ self.nodes_degree_in_weighted=np.array(degree_in_weighted)
+ self.nodes_degree_out_weighted=np.array(degree_out_weighted)
- # EDGE INFO INIT
- #################
-
- self.edges_hash=[]
- self.edges_hash_map = {}
- self.edges_hash_idx = {}
- for ix, ed in enumerate(self.edges_list):
- e1,e2=ed
- if not e1 in self.edges_hash_map:self.edges_hash_map[e1]={}
+ # EDGE INFO INIT
+ #################
- hash_=self.hash_edge_attr(e1,e2,self.edges_attr_list[ix]) if self.is_edge_attr else self.hash_edge(e1,e2)
- if self.is_multi and self.is_edge_attr:
- if not e2 in self.edges_hash_map[e1]:self.edges_hash_map[e1][e2]={}
- self.edges_hash_map[e1][e2][self.edges_attr_list[ix]]=hash_
- else:
- self.edges_hash_map[e1][e2]=hash_
- self.edges_hash_idx[hash_]=ix
- self.edges_hash.append(hash_)
- self.edges_hash_set=set(self.edges_hash)
+ self.edges_hash=[]
+ self.edges_hash_map = {}
+ self.edges_hash_idx = {}
+ for ix, ed in enumerate(self.edges_list):
+ e1,e2=ed
+ if not e1 in self.edges_hash_map:self.edges_hash_map[e1]={}
+
+ hash_=self.hash_edge_attr(e1,e2,self.edges_attr_list[ix]) if self.is_edge_attr else self.hash_edge(e1,e2)
+ if self.is_multi and self.is_edge_attr:
+ if not e2 in self.edges_hash_map[e1]:self.edges_hash_map[e1][e2]={}
+ self.edges_hash_map[e1][e2][self.edges_attr_list[ix]]=hash_
+ else:
+ self.edges_hash_map[e1][e2]=hash_
+ self.edges_hash_idx[hash_]=ix
+ self.edges_hash.append(hash_)
+ self.edges_hash_set=set(self.edges_hash)
- self.edges_weight={}
- for e1,e2,attr_dict in list(G.edges(data=True)):
- hash_=self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2)
- self.edges_weight[hash_]=attr_dict["weight"] if "weight" in attr_dict else 1
-
- self.number_of_edges = len(self.edges_list)
- self.number_of_nodes = len(self.nodes_list)
-
- if self.is_edge_attr and self.number_of_edges >0:
- self.number_of_edges_per_attr={attr:0 for attr in self.unique_edge_attr_vals}
- for _,_,attr_dict in list(G.edges(data=True)):
- self.number_of_edges_per_attr[attr_dict[self.edge_attr_key]]+=1
-
- if self.is_node_attr and self.number_of_nodes >0:
- self.number_of_nodes_per_attr={attr:0 for attr in self.unique_node_attr_vals}
- for _,attr_dict in list(G.nodes(data=True)):
- self.number_of_nodes_per_attr[attr_dict[self.node_attr_key]]+=1
+ self.edges_weight={}
+ for e1,e2,attr_dict in list(G.edges(data=True)):
+ hash_=self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2)
+ self.edges_weight[hash_]=attr_dict["weight"] if "weight" in attr_dict else 1
+
+ self.number_of_edges = len(self.edges_list)
+ self.number_of_nodes = len(self.nodes_list)
+
+ if self.is_edge_attr and self.number_of_edges >0:
+ self.number_of_edges_per_attr={attr:0 for attr in self.unique_edge_attr_vals}
+ for _,_,attr_dict in list(G.edges(data=True)):
+ self.number_of_edges_per_attr[attr_dict[self.edge_attr_key]]+=1
+
+ if self.is_node_attr and self.number_of_nodes >0:
+ self.number_of_nodes_per_attr={attr:0 for attr in self.unique_node_attr_vals}
+ for _,attr_dict in list(G.nodes(data=True)):
+ self.number_of_nodes_per_attr[attr_dict[self.node_attr_key]]+=1
# HASH FUNCTION
diff --git a/setup.py b/setup.py
index 71fcff81e83aed1c91979a981033d1f9c8ddcaef..20246d8d16e8ec736aadecd41a6942b320d642e9 100644
--- a/setup.py
+++ b/setup.py
@@ -78,7 +78,7 @@ setup(
]
)
#Clean cpp and compiled file
-f=True
+f=False
if f:
if os.path.exists("build"):
shutil.rmtree("build")