MNT Correct typos and simplify logic (scikit-learn#29897)

Micky774 · web-flow · commit 941ffbdaf947 · 2024-09-23T11:23:43.000+05:00
diff --git a/sklearn/cluster/_hdbscan/_linkage.pyx b/sklearn/cluster/_hdbscan/_linkage.pyx
@@ -74,8 +74,8 @@ cpdef cnp.ndarray[MST_edge_t, ndim=1, mode='c'] mst_from_mutual_reachability(
     Returns
     -------
     mst : ndarray of shape (n_samples - 1,), dtype=MST_edge_dtype
-        The MST representation of the mutual-reahability graph. The MST is
-        represented as a collecteion of edges.
+        The MST representation of the mutual-reachability graph. The MST is
+        represented as a collection of edges.
     """
     cdef:
         # Note: we utilize ndarray's over memory-views to make use of numpy
@@ -136,8 +136,8 @@ cpdef cnp.ndarray[MST_edge_t, ndim=1, mode='c'] mst_from_data_matrix(
     Returns
     -------
     mst : ndarray of shape (n_samples - 1,), dtype=MST_edge_dtype
-        The MST representation of the mutual-reahability graph. The MST is
-        represented as a collecteion of edges.
+        The MST representation of the mutual-reachability graph. The MST is
+        represented as a collection of edges.
     """
 
     cdef:
@@ -163,6 +163,8 @@ cpdef cnp.ndarray[MST_edge_t, ndim=1, mode='c'] mst_from_data_matrix(
 
     current_node = 0
 
+    # The following loop dynamically updates minimum reachability node-by-node,
+    # avoiding unnecessary computation where possible.
     for i in range(0, n_samples - 1):
 
         in_tree[current_node] = 1
@@ -194,25 +196,27 @@ cpdef cnp.ndarray[MST_edge_t, ndim=1, mode='c'] mst_from_data_matrix(
                 next_node_core_dist,
                 pair_distance
             )
-            if mutual_reachability_distance > next_node_min_reach:
-                if next_node_min_reach < new_reachability:
-                    new_reachability = next_node_min_reach
-                    source_node = next_node_source
-                    new_node = j
-                continue
 
+            # If MRD(i, j) is smaller than node j's min_reachability, we update
+            # node j's min_reachability for future reference.
             if mutual_reachability_distance < next_node_min_reach:
                 min_reachability[j] = mutual_reachability_distance
                 current_sources[j] = current_node
+
+                # If MRD(i, j) is also smaller than node i's current
+                # min_reachability, we update and set their edge as the current
+                # MST edge candidate.
                 if mutual_reachability_distance < new_reachability:
                     new_reachability = mutual_reachability_distance
                     source_node = current_node
                     new_node = j
-            else:
-                if next_node_min_reach < new_reachability:
-                    new_reachability = next_node_min_reach
-                    source_node = next_node_source
-                    new_node = j
+
+            # If the node j is closer to another node already in the tree, we
+            # make their edge the current MST candidate edge.
+            elif next_node_min_reach < new_reachability:
+                new_reachability = next_node_min_reach
+                source_node = next_node_source
+                new_node = j
 
         mst[i].current_node = source_node
         mst[i].next_node = new_node
@@ -227,8 +231,8 @@ cpdef cnp.ndarray[HIERARCHY_t, ndim=1, mode="c"] make_single_linkage(const MST_e
     Parameters
     ----------
     mst : ndarray of shape (n_samples - 1,), dtype=MST_edge_dtype
-        The MST representation of the mutual-reahability graph. The MST is
-        represented as a collecteion of edges.
+        The MST representation of the mutual-reachability graph. The MST is
+        represented as a collection of edges.
 
     Returns
     -------
diff --git a/sklearn/cluster/_hdbscan/_reachability.pyx b/sklearn/cluster/_hdbscan/_reachability.pyx
@@ -124,7 +124,7 @@ def _dense_mutual_reachability_graph(
     """
     cdef:
         intp_t i, j, n_samples = distance_matrix.shape[0]
-        floating mutual_reachibility_distance
+        floating mutual_reachability_distance
         floating[::1] core_distances
 
     # We assume that the distance matrix is symmetric. We choose to sort every
@@ -141,12 +141,12 @@ def _dense_mutual_reachability_graph(
         # _openmp_effective_n_threads
         for i in range(n_samples):
             for j in range(n_samples):
-                mutual_reachibility_distance = max(
+                mutual_reachability_distance = max(
                     core_distances[i],
                     core_distances[j],
                     distance_matrix[i, j],
                 )
-                distance_matrix[i, j] = mutual_reachibility_distance
+                distance_matrix[i, j] = mutual_reachability_distance
 
 
 def _sparse_mutual_reachability_graph(
@@ -179,7 +179,7 @@ def _sparse_mutual_reachability_graph(
     """
     cdef:
         integral i, col_ind, row_ind
-        floating mutual_reachibility_distance
+        floating mutual_reachability_distance
         floating[:] core_distances
         floating[:] row_data
 
@@ -203,10 +203,10 @@ def _sparse_mutual_reachability_graph(
         for row_ind in range(n_samples):
             for i in range(indptr[row_ind], indptr[row_ind + 1]):
                 col_ind = indices[i]
-                mutual_reachibility_distance = max(
+                mutual_reachability_distance = max(
                     core_distances[row_ind], core_distances[col_ind], data[i]
                 )
-                if isfinite(mutual_reachibility_distance):
-                    data[i] = mutual_reachibility_distance
+                if isfinite(mutual_reachability_distance):
+                    data[i] = mutual_reachability_distance
                 elif max_distance > 0:
                     data[i] = max_distance
diff --git a/sklearn/cluster/_hdbscan/_tree.pyx b/sklearn/cluster/_hdbscan/_tree.pyx
@@ -184,7 +184,7 @@ cpdef cnp.ndarray[CONDENSED_t, ndim=1, mode='c'] _condense_tree(
             left_count = 1
 
         if right >= n_samples:
-            right_count = <cnp.intp_t> hierarchy[right - n_samples].cluster_size
+            right_count = hierarchy[right - n_samples].cluster_size
         else:
             right_count = 1
 
