Merge remote-tracking branch 'origin/master'

# Conflicts:
#	hdbscan/hdbscan_.py
#	hdbscan/robust_single_linkage_.py

Author: lmcinnes

hdbscan/_hdbscan_boruvka.pyx

@@ -1,4 +1,5 @@
-#cython: boundscheck=False, nonecheck=False
+# cython: boundscheck=False
+# cython: nonecheck=False
 # Minimum spanning tree single linkage implementation for hdbscan
 # Authors: Leland McInnes, Steve Astels
 # License: 3-clause BSD
@@ -10,8 +11,10 @@ from libc.float cimport DBL_MAX
 
 from dist_metrics cimport DistanceMetric
 
+
 cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core(
-                               np.ndarray[np.double_t, ndim=2] distance_matrix):
+                               np.ndarray[np.double_t,
+                                          ndim=2] distance_matrix):
 
     cdef np.ndarray[np.intp_t, ndim=1] node_labels
     cdef np.ndarray[np.intp_t, ndim=1] current_labels
@@ -32,7 +35,7 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core(
     current_node = 0
     current_distances = np.infty * np.ones(distance_matrix.shape[0])
     current_labels = node_labels
-    for i in range(1,node_labels.shape[0]):
+    for i in range(1, node_labels.shape[0]):
         label_filter = current_labels != current_node
         current_labels = current_labels[label_filter]
         left = current_distances[label_filter]
@@ -48,12 +51,14 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core(
 
     return result
 
+
 cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector(
-                               np.ndarray[np.double_t, ndim=2, mode='c'] raw_data,
-                               np.ndarray[np.double_t, ndim=1, mode='c'] core_distances,
-                               DistanceMetric dist_metric,
-                               np.double_t alpha=1.0):
+        np.ndarray[np.double_t, ndim=2, mode='c'] raw_data,
+        np.ndarray[np.double_t, ndim=1, mode='c'] core_distances,
+        DistanceMetric dist_metric,
+        np.double_t alpha=1.0):
 
+    # Add a comment
     cdef np.ndarray[np.double_t, ndim=1] current_distances_arr
     cdef np.ndarray[np.int8_t, ndim=1] in_tree_arr
     cdef np.ndarray[np.double_t, ndim=2] result_arr
@@ -83,15 +88,16 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector(
     dim = raw_data.shape[0]
     num_features = raw_data.shape[1]
 
-    raw_data_view = (<np.double_t [:raw_data.shape[0], :raw_data.shape[1]:1]> (<np.double_t *> raw_data.data))
+    raw_data_view = (<np.double_t[:raw_data.shape[0], :raw_data.shape[1]:1]> (
+        <np.double_t *> raw_data.data))
     raw_data_ptr = (<np.double_t *> &raw_data_view[0, 0])
 
     result_arr = np.zeros((dim - 1, 3))
     in_tree_arr = np.zeros(dim, dtype=np.int8)
     current_node = 0
     current_distances_arr = np.infty * np.ones(dim)
 
-    result = (<np.double_t [:dim - 1, :3:1]> (<np.double_t *> result_arr.data))
+    result = (<np.double_t[:dim - 1, :3:1]> (<np.double_t *> result_arr.data))
     in_tree = (<np.int8_t *> in_tree_arr.data)
     current_distances = (<np.double_t *> current_distances_arr.data)
     current_core_distances = (<np.double_t *> core_distances.data)
@@ -110,15 +116,18 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector(
                 continue
 
             right_value = current_distances[j]
-            left_value = dist_metric.dist(&raw_data_ptr[num_features * current_node],
+            left_value = dist_metric.dist(&raw_data_ptr[num_features *
+                                                        current_node],
                                           &raw_data_ptr[num_features * j],
                                           num_features)
 
             if alpha != 1.0:
                 left_value /= alpha
 
             core_value = core_distances[j]
-            if current_node_core_distance > right_value or core_value > right_value or left_value > right_value:
+            if (current_node_core_distance > right_value or
+                    core_value > right_value or
+                    left_value > right_value):
                 if right_value < new_distance:
                     new_distance = right_value
                     new_node = j
@@ -148,6 +157,7 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector(
 
     return result_arr
 
+
 cdef class UnionFind (object):
 
     cdef np.ndarray parent_arr
@@ -183,6 +193,7 @@ cdef class UnionFind (object):
             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
@@ -192,7 +203,8 @@ cpdef np.ndarray[np.double_t, ndim=2] label(np.ndarray[np.double_t, ndim=2] L):
     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))
+    result = (<np.double_t[:L.shape[0], :4:1]> (
+        <np.double_t *> result_arr.data))
     N = L.shape[0] + 1
     U = UnionFind(N)
 
@@ -208,18 +220,18 @@ cpdef np.ndarray[np.double_t, ndim=2] label(np.ndarray[np.double_t, ndim=2] L):
         result[index][1] = bb
         result[index][2] = delta
         result[index][3] = U.size[aa] + U.size[bb]
-        
+
         U.union(aa, bb)
-       
+
     return result_arr
 
+
 cpdef np.ndarray[np.double_t, ndim=2] single_linkage(distance_matrix):
-    
+
     cdef np.ndarray[np.double_t, ndim=2] hierarchy
     cdef np.ndarray[np.double_t, ndim=2] for_labelling
-    
+
     hierarchy = mst_linkage_core(distance_matrix)
     for_labelling = hierarchy[np.argsort(hierarchy.T[2]), :]
-    return label(for_labelling)
 
-    
+    return label(for_labelling)

hdbscan/_hdbscan_linkage.pyx

@@ -1,4 +1,6 @@
-#cython: boundscheck=False, nonecheck=False, initializedcheck=False
+# cython: boundscheck=False
+# cython: nonecheck=False
+# cython: initializedcheck=False
 # mutual reachability distance compiutations
 # Authors: Leland McInnes
 # License: 3-clause BSD
@@ -11,51 +13,54 @@ from scipy.sparse import lil_matrix as sparse_matrix
 from sklearn.neighbors import KDTree, BallTree
 import gc
 
+
 def mutual_reachability(distance_matrix, min_points=5, alpha=1.0):
     """Compute the weighted adjacency matrix of the mutual reachability
     graph of a distance matrix.
-    
+
     Parameters
     ----------
-    distance_matrix : array [n_samples, n_samples]
+    distance_matrix : ndarray, shape (n_samples, n_samples)
         Array of distances between samples.
-        
-    min_points : int optional
+
+    min_points : int, optional (default=5)
         The number of points in a neighbourhood for a point to be considered
-        a core point. (defaults to 5)
+        a core point.
 
     Returns
     -------
-    mututal_reachability: array [n_samples, n_samples]
+    mututal_reachability: ndarray, shape (n_samples, n_samples)
         Weighted adjacency matrix of the mutual reachability graph.
-        
+
     References
     ----------
-    R. Campello, D. Moulavi, and J. Sander, "Density-Based Clustering Based on
-    Hierarchical Density Estimates"
-    In: Advances in Knowledge Discovery and Data Mining, Springer, pp 160-172.
-    2013
+    .. [1] Campello, R. J., Moulavi, D., & Sander, J. (2013, April).
+       Density-based clustering based on hierarchical density estimates.
+       In Pacific-Asia Conference on Knowledge Discovery and Data Mining
+       (pp. 160-172). Springer Berlin Heidelberg.
     """
     size = distance_matrix.shape[0]
     min_points = min(size - 1, min_points)
     try:
-        core_distances = np.partition(distance_matrix, 
-                                      min_points, 
+        core_distances = np.partition(distance_matrix,
+                                      min_points,
                                       axis=0)[min_points]
     except AttributeError:
         core_distances = np.sort(distance_matrix,
                                  axis=0)[min_points]
 
     if alpha != 1.0:
         distance_matrix = distance_matrix / alpha
-                                  
-    stage1 = np.where(core_distances > distance_matrix, 
+
+    stage1 = np.where(core_distances > distance_matrix,
                       core_distances, distance_matrix)
     result = np.where(core_distances > stage1.T,
                       core_distances.T, stage1.T).T
     return result
 
-cpdef sparse_mutual_reachability(object lil_matrix, np.intp_t min_points=5, float alpha=1.0):
+
+cpdef sparse_mutual_reachability(object lil_matrix, np.intp_t min_points=5,
+                                 float alpha=1.0):
 
     cdef np.intp_t i
     cdef np.intp_t j
@@ -88,7 +93,9 @@ cpdef sparse_mutual_reachability(object lil_matrix, np.intp_t min_points=5, floa
 
     return result.tocsr()
 
-def kdtree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5, alpha=1.0, **kwargs):
+
+def kdtree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5,
+                               alpha=1.0, **kwargs):
     dim = distance_matrix.shape[0]
     min_points = min(dim - 1, min_points)
 
@@ -97,7 +104,7 @@ def kdtree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5, al
     else:
         tree = KDTree(X, metric=metric, **kwargs)
 
-    core_distances = tree.query(X, k=min_points)[0][:,-1]
+    core_distances = tree.query(X, k=min_points)[0][:, -1]
 
     if alpha != 1.0:
         distance_matrix = distance_matrix / alpha
@@ -108,13 +115,15 @@ def kdtree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5, al
                       core_distances.T, stage1.T).T
     return result
 
-def balltree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5, alpha=1.0, **kwargs):
+
+def balltree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5,
+                                 alpha=1.0, **kwargs):
     dim = distance_matrix.shape[0]
     min_points = min(dim - 1, min_points)
 
     tree = BallTree(X, metric=metric, **kwargs)
 
-    core_distances = tree.query(X, k=min_points)[0][:,-1]
+    core_distances = tree.query(X, k=min_points)[0][:, -1]
 
     if alpha != 1.0:
         distance_matrix = distance_matrix / alpha
@@ -125,8 +134,10 @@ def balltree_mutual_reachability(X, distance_matrix, metric, p=2, min_points=5,
                       core_distances.T, stage1.T).T
     return result
 
+
 cdef np.ndarray[np.double_t, ndim=1] mutual_reachability_from_pdist(
-        np.ndarray[np.double_t, ndim=1] core_distances, np.ndarray[np.double_t, ndim=1] dists, np.intp_t dim):
+        np.ndarray[np.double_t, ndim=1] core_distances,
+        np.ndarray[np.double_t, ndim=1] dists, np.intp_t dim):
 
     cdef np.intp_t i
     cdef np.intp_t j
@@ -148,7 +159,8 @@ cdef np.ndarray[np.double_t, ndim=1] mutual_reachability_from_pdist(
     return dists
 
 
-def kdtree_pdist_mutual_reachability(X,  metric, p=2, min_points=5, alpha=1.0, **kwargs):
+def kdtree_pdist_mutual_reachability(X,  metric, p=2, min_points=5, alpha=1.0,
+                                     **kwargs):
 
     dim = X.shape[0]
     min_points = min(dim - 1, min_points)
@@ -158,7 +170,7 @@ def kdtree_pdist_mutual_reachability(X,  metric, p=2, min_points=5, alpha=1.0, *
     else:
         tree = KDTree(X, metric=metric, **kwargs)
 
-    core_distances = tree.query(X, k=min_points)[0][:,-1]
+    core_distances = tree.query(X, k=min_points)[0][:, -1]
 
     del tree
     gc.collect()
@@ -172,14 +184,16 @@ def kdtree_pdist_mutual_reachability(X,  metric, p=2, min_points=5, alpha=1.0, *
 
     return dists
 
-def balltree_pdist_mutual_reachability(X, metric, p=2, min_points=5, alpha=1.0, **kwargs):
+
+def balltree_pdist_mutual_reachability(X, metric, p=2, min_points=5, alpha=1.0,
+                                       **kwargs):
 
     dim = X.shape[0]
     min_points = min(dim - 1, min_points)
 
     tree = BallTree(X, metric=metric, **kwargs)
 
-    core_distances = tree.query(X, k=min_points)[0][:,-1]
+    core_distances = tree.query(X, k=min_points)[0][:, -1]
 
     del tree
     gc.collect()