Spacing changes.

Author: lmcinnes

hdbscan/_hdbscan_linkage.pyx

@@ -23,14 +23,14 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core(
     cdef np.ndarray[np.double_t, ndim=1] left
     cdef np.ndarray[np.double_t, ndim=1] right
     cdef np.ndarray[np.double_t, ndim=2] result
-    
+
     cdef np.ndarray label_filter
-    
+
     cdef np.intp_t current_node
     cdef np.intp_t new_node_index
     cdef np.intp_t new_node
     cdef np.intp_t i
-    
+
     result = np.zeros((distance_matrix.shape[0] - 1, 3))
     node_labels = np.arange(distance_matrix.shape[0], dtype=np.intp)
     current_node = 0
@@ -42,14 +42,14 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core(
         left = current_distances[label_filter]
         right = distance_matrix[current_node][current_labels]
         current_distances = np.where(left < right, left, right)
-        
+
         new_node_index = np.argmin(current_distances)
         new_node = current_labels[new_node_index]
         result[i - 1, 0] = <double> current_node
         result[i - 1, 1] = <double> new_node
         result[i - 1, 2] = current_distances[new_node_index]
         current_node = new_node
-        
+
     return result
 
 cdef void select_distances(
@@ -93,9 +93,9 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_pdist(
     cdef np.ndarray[np.double_t, ndim=1] right
     cdef np.ndarray[np.intp_t, ndim=1] col_select
     cdef np.ndarray[np.double_t, ndim=2] result
-    
+
     cdef np.ndarray label_filter
-    
+
     cdef np.intp_t current_node
     cdef np.intp_t new_node_index
     cdef np.intp_t new_node
@@ -104,7 +104,7 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_pdist(
 
     dim = int((1 + np.sqrt(1 + 8 * pdist_matrix.shape[0])) / 2.0)
     col_select = np.cumsum(np.arange(dim - 1, 0, -1))
-    
+
     result = np.zeros((dim - 1, 3))
     node_labels = np.arange(dim, dtype=np.intp)
     current_node = 0
@@ -118,14 +118,14 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_pdist(
         #right = fill_row(pdist_matrix, current_node, dim, col_select)[current_labels]
         select_distances(pdist_matrix, col_select, current_labels, right, current_node, dim)
         current_distances = np.where(left < right[:len(current_labels)], left, right[:len(current_labels)])
-        
+
         new_node_index = np.argmin(current_distances)
         new_node = current_labels[new_node_index]
         result[i - 1, 0] = <double> current_node
         result[i - 1, 1] = <double> new_node
         result[i - 1, 2] = current_distances[new_node_index]
         current_node = new_node
-        
+
     return result
 
 
@@ -244,29 +244,29 @@ cdef class UnionFind (object):
     cdef np.intp_t next_label
     cdef np.intp_t *parent
     cdef np.intp_t *size
-    
+
     def __init__(self, N):
         self.parent_arr = -1 * np.ones(2 * N - 1, dtype=np.intp)
         self.next_label = N
         self.size_arr = np.hstack((np.ones(N, dtype=np.intp),
                                    np.zeros(N-1, dtype=np.intp)))
         self.parent = (<np.intp_t *> self.parent_arr.data)
         self.size = (<np.intp_t *> self.size_arr.data)
-                               
+
     cdef void union(self, np.intp_t m, np.intp_t n):
         self.size[self.next_label] = self.size[m] + self.size[n]
         self.parent[m] = self.next_label
         self.parent[n] = self.next_label
         self.size[self.next_label] = self.size[m] + self.size[n]
         self.next_label += 1
-        
+
         return
-        
+
     cdef np.intp_t find(self, np.intp_t n):
         while self.parent[n] != -1:
             n = self.parent[n]
         return n
-        
+
     cdef np.intp_t fast_find(self, np.intp_t n):
         cdef np.intp_t p
         p = n
@@ -276,15 +276,15 @@ cdef class UnionFind (object):
         while self.parent_arr[p] != n:
             p, self.parent_arr[p] = self.parent_arr[p], n
         return n
-        
+
 cpdef np.ndarray[np.double_t, ndim=2] label(np.ndarray[np.double_t, ndim=2] L):
 
     cdef np.ndarray[np.double_t, ndim=2] result_arr
     cdef np.double_t[:, ::1] result
 
     cdef np.intp_t N, a, aa, b, bb, idx
     cdef np.double_t delta
-    
+
     result_arr = np.zeros((L.shape[0], L.shape[1] + 1))
     result = (<np.double_t[:L.shape[0], :4:1]> (<np.double_t *> result_arr.data))
     N = L.shape[0] + 1

hdbscan/_hdbscan_tree.pyx

@@ -13,7 +13,7 @@ cdef list bfs_from_hierarchy(np.ndarray[np.double_t, ndim=2] hierarchy, np.intp_
     """
     Perform a breadth first search on a tree in scipy hclust format.
     """
-    
+
     cdef list to_process
     cdef np.intp_t max_node
     cdef np.intp_t num_points
@@ -28,13 +28,13 @@ cdef list bfs_from_hierarchy(np.ndarray[np.double_t, ndim=2] hierarchy, np.intp_
 
     while to_process:
         result.extend(to_process)
-        to_process = [x - num_points for x in 
+        to_process = [x - num_points for x in
                           to_process if x >= num_points]
         if to_process:
             to_process = hierarchy[to_process,:2].flatten().astype(np.intp).tolist()
 
     return result
-        
+
 cpdef np.ndarray condense_tree(np.ndarray[np.double_t, ndim=2] hierarchy,
                           np.intp_t min_cluster_size=10):
 
@@ -55,22 +55,22 @@ cpdef np.ndarray condense_tree(np.ndarray[np.double_t, ndim=2] hierarchy,
     cdef double lambda_value
     cdef np.intp_t left_count
     cdef np.intp_t right_count
-    
+
     root = 2 * hierarchy.shape[0]
     num_points = root // 2 + 1
     next_label = num_points + 1
-    
+
     node_list = bfs_from_hierarchy(hierarchy, root)
-    
+
     relabel = np.empty(len(node_list), dtype=np.intp)
     relabel[root] = num_points
     result_list = []
     ignore = np.zeros(len(node_list), dtype=np.int)
-    
+
     for node in node_list:
         if ignore[node] or node < num_points:
             continue
-            
+
         children = hierarchy[node - num_points]
         left = <np.intp_t> children[0]
         right = <np.intp_t> children[1]
@@ -88,41 +88,41 @@ cpdef np.ndarray condense_tree(np.ndarray[np.double_t, ndim=2] hierarchy,
             right_count = <np.intp_t> hierarchy[right - num_points][3]
         else:
             right_count = 1
-        
+
         if left_count >= min_cluster_size and right_count >= min_cluster_size:
             relabel[left] = next_label
             next_label += 1
             result_list.append((relabel[node], relabel[left], lambda_value, left_count))
-            
+
             relabel[right] = next_label
             next_label += 1
             result_list.append((relabel[node], relabel[right], lambda_value, right_count))
-            
+
         elif left_count < min_cluster_size and right_count < min_cluster_size:
             for sub_node in bfs_from_hierarchy(hierarchy, left):
                 if sub_node < num_points:
                     result_list.append((relabel[node], sub_node, lambda_value, 1))
                 ignore[sub_node] = True
-                
+
             for sub_node in bfs_from_hierarchy(hierarchy, right):
                 if sub_node < num_points:
                     result_list.append((relabel[node], sub_node, lambda_value, 1))
                 ignore[sub_node] = True
-                
+
         elif left_count < min_cluster_size:
             relabel[right] = relabel[node]
             for sub_node in bfs_from_hierarchy(hierarchy, left):
                 if sub_node < num_points:
                     result_list.append((relabel[node], sub_node, lambda_value, 1))
                 ignore[sub_node] = True
-                
+
         else:
             relabel[left] = relabel[node]
             for sub_node in bfs_from_hierarchy(hierarchy, right):
                 if sub_node < num_points:
                     result_list.append((relabel[node], sub_node, lambda_value, 1))
                 ignore[sub_node] = True
-                
+
     return np.array(result_list, dtype=[
                                         ('parent', np.intp),
                                         ('child', np.intp),
@@ -203,7 +203,7 @@ cdef list bfs_from_cluster_tree(np.ndarray tree, np.intp_t bfs_root):
 
     result = []
     to_process = np.array([bfs_root], dtype=np.intp)
-    
+
     while to_process.shape[0] > 0:
         result.extend(to_process.tolist())
         to_process = tree['child'][np.in1d(tree['parent'], to_process)]