PEP 8 for dis_metric.pyx

Author: Guillaume Lemaitre

hdbscan/dist_metrics.pyx

@@ -1,7 +1,7 @@
-#!python
-#cython: boundscheck=False
-#cython: wraparound=False
-#cython: cdivision=True
+# !python
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: cdivision=True
 
 # By Jake Vanderplas (2013) <[email protected]>
 # written for the scikit-learn project
@@ -22,7 +22,7 @@ ITYPE = np.intp
 # Numpy 1.3-1.4 compatibility utilities
 cdef DTYPE_t[:, ::1] get_memview_DTYPE_2D(
                                np.ndarray[DTYPE_t, ndim=2, mode='c'] X):
-    return <DTYPE_t[:X.shape[0],:X.shape[1]:1]> (<DTYPE_t*> X.data)
+    return <DTYPE_t[:X.shape[0], :X.shape[1]:1]> (<DTYPE_t*> X.data)
 
 
 cdef DTYPE_t* get_vec_ptr(np.ndarray[DTYPE_t, ndim=1, mode='c'] vec):
@@ -98,7 +98,8 @@ def get_valid_metric_ids(L):
     """Given an iterable of metric class names or class identifiers,
     return a list of metric IDs which map to those classes.
 
-    Example:
+    Examples
+    --------
     >>> L = get_valid_metric_ids([EuclideanDistance, 'ManhattanDistance'])
     >>> sorted(L)
     ['cityblock', 'euclidean', 'l1', 'l2', 'manhattan']
@@ -115,6 +116,10 @@ cdef class DistanceMetric:
     This class provides a uniform interface to fast distance metric
     functions.  The various metrics can be accessed via the `get_metric`
     class method and the metric string identifier (see below).
+
+    Examples
+    --------
+
     For example, to use the Euclidean distance:
 
     >>> dist = DistanceMetric.get_metric('euclidean')
@@ -391,20 +396,20 @@ cdef class DistanceMetric:
         Xarr = np.asarray(X, dtype=DTYPE, order='C')
         if Y is None:
             Darr = np.zeros((Xarr.shape[0], Xarr.shape[0]),
-                         dtype=DTYPE, order='C')
+                            dtype=DTYPE, order='C')
             self.pdist(get_memview_DTYPE_2D(Xarr),
                        get_memview_DTYPE_2D(Darr))
         else:
             Yarr = np.asarray(Y, dtype=DTYPE, order='C')
             Darr = np.zeros((Xarr.shape[0], Yarr.shape[0]),
-                         dtype=DTYPE, order='C')
+                            dtype=DTYPE, order='C')
             self.cdist(get_memview_DTYPE_2D(Xarr),
                        get_memview_DTYPE_2D(Yarr),
                        get_memview_DTYPE_2D(Darr))
         return Darr
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Euclidean Distance
 #  d = sqrt(sum(x_i^2 - y_i^2))
 cdef class EuclideanDistance(DistanceMetric):
@@ -437,7 +442,7 @@ cdef class EuclideanDistance(DistanceMetric):
         return dist ** 2
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # SEuclidean Distance
 #  d = sqrt(sum((x_i - y_i2)^2 / v_i))
 cdef class SEuclideanDistance(DistanceMetric):
@@ -481,7 +486,7 @@ cdef class SEuclideanDistance(DistanceMetric):
         return dist ** 2
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Manhattan Distance
 #  d = sum(abs(x_i - y_i))
 cdef class ManhattanDistance(DistanceMetric):
@@ -502,7 +507,7 @@ cdef class ManhattanDistance(DistanceMetric):
         return d
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Chebyshev Distance
 #  d = max_i(abs(x_i), abs(y_i))
 cdef class ChebyshevDistance(DistanceMetric):
@@ -523,7 +528,7 @@ cdef class ChebyshevDistance(DistanceMetric):
         return d
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Minkowski Distance
 #  d = sum(x_i^p - y_i^p) ^ (1/p)
 cdef class MinkowskiDistance(DistanceMetric):
@@ -570,7 +575,7 @@ cdef class MinkowskiDistance(DistanceMetric):
         return dist ** self.p
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # W-Minkowski Distance
 #  d = sum(w_i * (x_i^p - y_i^p)) ^ (1/p)
 cdef class WMinkowskiDistance(DistanceMetric):
@@ -629,7 +634,7 @@ cdef class WMinkowskiDistance(DistanceMetric):
         return dist ** self.p
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Mahalanobis Distance
 #  d = sqrt( (x - y)^T V^-1 (x - y) )
 cdef class MahalanobisDistance(DistanceMetric):
@@ -699,7 +704,7 @@ cdef class MahalanobisDistance(DistanceMetric):
         return dist ** 2
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Hamming Distance
 #  d = N_unequal(x, y) / N_tot
 cdef class HammingDistance(DistanceMetric):
@@ -721,7 +726,7 @@ cdef class HammingDistance(DistanceMetric):
         return float(n_unequal) / size
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Canberra Distance
 #  D(x, y) = sum[ abs(x_i - y_i) / (abs(x_i) + abs(y_i)) ]
 cdef class CanberraDistance(DistanceMetric):
@@ -744,7 +749,7 @@ cdef class CanberraDistance(DistanceMetric):
         return d
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Bray-Curtis Distance
 #  D(x, y) = sum[abs(x_i - y_i)] / sum[abs(x_i) + abs(y_i)]
 cdef class BrayCurtisDistance(DistanceMetric):
@@ -769,7 +774,7 @@ cdef class BrayCurtisDistance(DistanceMetric):
             return 0.0
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Jaccard Distance (boolean)
 #  D(x, y) = N_unequal(x, y) / N_nonzero(x, y)
 cdef class JaccardDistance(DistanceMetric):
@@ -796,7 +801,7 @@ cdef class JaccardDistance(DistanceMetric):
         return (nnz - n_eq) * 1.0 / nnz
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Matching Distance (boolean)
 #  D(x, y) = n_neq / n
 cdef class MatchingDistance(DistanceMetric):
@@ -820,7 +825,7 @@ cdef class MatchingDistance(DistanceMetric):
         return n_neq * 1. / size
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Dice Distance (boolean)
 #  D(x, y) = n_neq / (2 * ntt + n_neq)
 cdef class DiceDistance(DistanceMetric):
@@ -845,7 +850,7 @@ cdef class DiceDistance(DistanceMetric):
         return n_neq / (2.0 * ntt + n_neq)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Kulsinski Distance (boolean)
 #  D(x, y) = (ntf + nft - ntt + n) / (n_neq + n)
 cdef class KulsinskiDistance(DistanceMetric):
@@ -870,7 +875,7 @@ cdef class KulsinskiDistance(DistanceMetric):
         return (n_neq - ntt + size) * 1.0 / (n_neq + size)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Rogers-Tanimoto Distance (boolean)
 #  D(x, y) = 2 * n_neq / (n + n_neq)
 cdef class RogersTanimotoDistance(DistanceMetric):
@@ -894,7 +899,7 @@ cdef class RogersTanimotoDistance(DistanceMetric):
         return (2.0 * n_neq) / (size + n_neq)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Russell-Rao Distance (boolean)
 #  D(x, y) = (n - ntt) / n
 cdef class RussellRaoDistance(DistanceMetric):
@@ -918,7 +923,7 @@ cdef class RussellRaoDistance(DistanceMetric):
         return (size - ntt) * 1. / size
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Sokal-Michener Distance (boolean)
 #  D(x, y) = 2 * n_neq / (n + n_neq)
 cdef class SokalMichenerDistance(DistanceMetric):
@@ -942,7 +947,7 @@ cdef class SokalMichenerDistance(DistanceMetric):
         return (2.0 * n_neq) / (size + n_neq)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Sokal-Sneath Distance (boolean)
 #  D(x, y) = n_neq / (0.5 * n_tt + n_neq)
 cdef class SokalSneathDistance(DistanceMetric):
@@ -967,7 +972,7 @@ cdef class SokalSneathDistance(DistanceMetric):
         return n_neq / (0.5 * ntt + n_neq)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Haversine Distance (2 dimensional)
 #  D(x, y) = 2 arcsin{sqrt[sin^2 ((x1 - y1) / 2)
 #                          + cos(x1) cos(y1) sin^2 ((x2 - y2) / 2)]}
@@ -994,14 +999,15 @@ cdef class HaversineDistance(DistanceMetric):
         return (sin_0 * sin_0 + cos(x1[0]) * cos(x2[0]) * sin_1 * sin_1)
 
     cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2,
-                              ITYPE_t size) nogil except -1:
+                             ITYPE_t size) nogil except -1:
         if size != 2:
             with gil:
-                raise ValueError("Haversine distance only valid in 2 dimensions")
+                raise ValueError("Haversine distance only valid in"
+                                 " 2 dimensions")
         cdef DTYPE_t sin_0 = sin(0.5 * (x1[0] - x2[0]))
         cdef DTYPE_t sin_1 = sin(0.5 * (x1[1] - x2[1]))
-        return 2 * asin(sqrt(sin_0 * sin_0
-                             + cos(x1[0]) * cos(x2[0]) * sin_1 * sin_1))
+        return 2 * asin(sqrt(sin_0 * sin_0 +
+                             cos(x1[0]) * cos(x2[0]) * sin_1 * sin_1))
 
     cdef inline DTYPE_t _rdist_to_dist(self, DTYPE_t rdist) except -1:
         return 2 * asin(sqrt(rdist))
@@ -1018,12 +1024,12 @@ cdef class HaversineDistance(DistanceMetric):
         return tmp * tmp
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Yule Distance (boolean)
 #  D(x, y) = 2 * ntf * nft / (ntt * nff + ntf * nft)
 # [This is not a true metric, so we will leave it out.]
 #
-#cdef class YuleDistance(DistanceMetric):
+# cdef class YuleDistance(DistanceMetric):
 #    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2, ITYPE_t size):
 #        cdef int tf1, tf2, ntf = 0, nft = 0, ntt = 0, nff = 0
 #        cdef np.intp_t j
@@ -1037,13 +1043,15 @@ cdef class HaversineDistance(DistanceMetric):
 #        return (2.0 * ntf * nft) / (ntt * nff + ntf * nft)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Cosine Distance
 #  D(x, y) = dot(x, y) / (|x| * |y|)
-# [This is not a true metric, so we will leave it out. Use the `arccos` distance instead]
+# [This is not a true metric, so we will leave it out. Use the `arccos`
+#  distance instead]
 
-#cdef class CosineDistance(DistanceMetric):
-#    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2, ITYPE_t size) nogil except -1:
+# cdef class CosineDistance(DistanceMetric):
+#    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2,
+#                             ITYPE_t size) nogil except -1:
 #        cdef DTYPE_t d = 0, norm1 = 0, norm2 = 0
 #        cdef np.intp_t j
 #        for j in range(size):
@@ -1052,12 +1060,13 @@ cdef class HaversineDistance(DistanceMetric):
 #            norm2 += x2[j] * x2[j]
 #        return 1.0 - d / sqrt(norm1 * norm2)
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Arccos Distance
 #  D(x, y) = arccos(dot(x, y) / (|x| * |y|)) / PI
 
 cdef class ArccosDistance(DistanceMetric):
-    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2, ITYPE_t size) nogil except -1:
+    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2,
+                             ITYPE_t size) nogil except -1:
         cdef DTYPE_t d = 0, norm1 = 0, norm2 = 0
         cdef np.intp_t j
         for j in range(size):
@@ -1067,13 +1076,12 @@ cdef class ArccosDistance(DistanceMetric):
         return acos(1.0 - d / sqrt(norm1 * norm2)) / M_PI
 
 
-
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # Correlation Distance
 #  D(x, y) = dot((x - mx), (y - my)) / (|x - mx| * |y - my|)
 # [This is not a true metric, so we will leave it out.]
 #
-#cdef class CorrelationDistance(DistanceMetric):
+# cdef class CorrelationDistance(DistanceMetric):
 #    cdef inline DTYPE_t dist(self, DTYPE_t* x1, DTYPE_t* x2, ITYPE_t size):
 #        cdef DTYPE_t mu1 = 0, mu2 = 0, x1nrm = 0, x2nrm = 0, x1Tx2 = 0
 #        cdef DTYPE_t tmp1, tmp2
@@ -1095,7 +1103,7 @@ cdef class ArccosDistance(DistanceMetric):
 #        return (1. - x1Tx2) / sqrt(x1nrm * x2nrm)
 
 
-#------------------------------------------------------------
+# ------------------------------------------------------------
 # User-defined distance
 #
 cdef class PyFuncDistance(DistanceMetric):
@@ -1134,4 +1142,4 @@ cdef class PyFuncDistance(DistanceMetric):
 
 
 cdef inline double fmax(double a, double b) nogil:
-    return max(a, b)
+    return max(a, b)