RF: move dnodecom and node_degree into WeightedPartition object

Author: CindeeM

brainx/tests/test_weighted_modularity.py

@@ -89,6 +89,11 @@ def test_get_node_community(self):
         part = wm.WeightedPartition(self.graph)
         self.assertEqual(part.get_node_community(0), 0)
 
+    def test_node_degree(self):
+        part = wm.WeightedPartition(self.graph) # one comm per node   
+        node = 0    
+        res = part.node_degree(node)
+        npt.assert_almost_equal(res, 37.94151675 )
 
     def test_modularity(self):
         part = wm.WeightedPartition(self.graph, self.communities)
@@ -114,21 +119,20 @@ def test_internal_links(self):
 
 
 
-def test_dnodecom():
-    graph, communities = get_test_data()
-    part = wm.WeightedPartition(graph) # one comm per node
-    node = 0
-    node2comm_weights = wm.dnodecom(node, part)
-    # self loops not added to weight 
-    # so communities made only of node should be zero
-    npt.assert_equal(node2comm_weights[0],0)
-    # this should be equal to weight between two nodes
-    neighbor = 1
-    expected = graph[node][neighbor]['weight']
-    npt.assert_equal(node2comm_weights[neighbor],expected)
-    part = wm.WeightedPartition(graph, communities)
-    node2comm_weights = wm.dnodecom(node, part)
-    npt.assert_equal(len(node2comm_weights), 2) 
+    def test_dnodecom(self):
+        part = wm.WeightedPartition(self.graph) # one comm per node
+        node = 0
+        node2comm_weights = part.dnodecom(node)
+        # self loops not added to weight 
+        # so communities made only of node should be zero
+        npt.assert_equal(node2comm_weights[0],0)
+        # this should be equal to weight between two nodes
+        neighbor = 1
+        expected = self.graph[node][neighbor]['weight']
+        npt.assert_equal(node2comm_weights[neighbor],expected)
+        part = wm.WeightedPartition(self.graph, self.communities)
+        node2comm_weights = part.dnodecom(node)
+        npt.assert_equal(len(node2comm_weights), 2) 
 
 def test_meta_graph():
     graph, communities = get_test_data()
@@ -176,12 +180,6 @@ def test_communities_nodes_alledgesw():
 
 
 
-def test_node_degree():
-    graph, communities = get_test_data()
-    part = wm.WeightedPartition(graph) # one comm per node   
-    node = 0    
-    res = wm.node_degree(graph, node)
-    npt.assert_almost_equal(res, 37.94151675 )
 
 def test_combine():
     first = [set([0,1,2]), set([3,4,5]), set([6,7])]

brainx/weighted_modularity.py

@@ -91,6 +91,23 @@ def _allnodes_in_communities(self, communities):
         return len(self.graph.nodes()) == \
             len([item for com in communities for item in com])
 
+    def node_degree(self, node):
+        """ find the summed weight of all node edges
+        """
+        return self.graph.degree(weight='weight')[node]
+
+
+    def dnodecom(self, node):
+        """ Find the number of links from node to each community"""
+        comm_weights = [0] * len(self.communities)
+        for neighbor, data in self.graph[node].items():
+            if neighbor == node:
+                continue
+            tmpcomm = self.get_node_community(neighbor)
+            comm_weights[tmpcomm] += data.get('weight', 1)
+        return comm_weights
+
+
     def total_links(self):
         """ sum of all links inside or outside community
         no nodes are missing"""
@@ -207,22 +224,8 @@ def _communities_nodes_alledgesw(part, removed_node):
     return weights  
 
 
-def node_degree(graph, node):
-    """ find the summed weight to node
-    Ki in Blondel paper"""
-    return graph.degree(weight='weight')[node]
 
 
-def dnodecom(node, part):
-    """ Find the number of links from node to each community"""
-    comm_weights = [0] * len(part.communities)
-    for neighbor, data in part.graph[node].items():
-        if neighbor == node:
-            continue
-        tmpcomm = part.get_node_community(neighbor)
-        comm_weights[tmpcomm] += data.get('weight', 1)
-    return comm_weights
-
 
 
 def gen_dendogram(graph, communities=None, minthr=0.0000001):
@@ -285,8 +288,8 @@ def _calc_delta_modularity(node, part):
     """calculate the increase(s) in modularity if node is moved to other
     communities
     deltamod = inC - totc * ki / total_weight"""
-    noded = node_degree(part.graph, node)
-    dnc = dnodecom(node, part)
+    noded = part.node_degree(node)
+    dnc = part.dnodecom(node)
     totc = _communities_nodes_alledgesw(part, node)
     total_weight = part.total_edge_weight
     # cast to arrays to improve calc