applied pre-commit

Author: Feelx234

.github/workflows/pythonapp.yml

@@ -41,4 +41,4 @@ jobs:
 #        # stop the build if there are Python syntax errors or undefined names
 #        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
 #        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-#        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+#        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

.github/workflows/release_to_pypi.yml

@@ -37,4 +37,4 @@ jobs:
       - name: Publish a Python distribution to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          password: ${{ secrets.PYPI_API_TOKEN }}
+          password: ${{ secrets.PYPI_API_TOKEN }}

fast1dkmeans/__init__.py

@@ -1 +1 @@
-from fast1dkmeans.main import cluster
+from fast1dkmeans.main import cluster

fast1dkmeans/common.py

@@ -2,38 +2,38 @@
 from numba import njit, float64, int64
 from numba.experimental import jitclass
 
-USE_CACHE=True
+USE_CACHE = True
+
 
 @njit([(float64[:],)], cache=USE_CACHE)
 def calc_cumsum(v):
-    cumsum = np.empty(len(v)+1, dtype=np.float64)
-    cumsum[0]=0
+    cumsum = np.empty(len(v) + 1, dtype=np.float64)
+    cumsum[0] = 0
     cumsum[1:] = np.cumsum(v)
     return cumsum
 
+
 @njit([(float64[:],)], cache=USE_CACHE)
 def calc_cumsum2(v):
-    cumsum2 = np.empty(len(v)+1, dtype=np.float64)
-    cumsum2[0]=0
+    cumsum2 = np.empty(len(v) + 1, dtype=np.float64)
+    cumsum2[0] = 0
     cumsum2[1:] = np.cumsum(np.square(v))
     return cumsum2
 
 
-
 @njit([(float64[:], float64[:], int64, int64)], cache=USE_CACHE)
 def calc_objective(cumsum, cumsum2, i, j):
     if j <= i:
         return 0.0
-#            raise ValueError("j should never be larger than i")
-    mu = (cumsum[j+1]-cumsum[i])/(j-i+1)
+    #            raise ValueError("j should never be larger than i")
+    mu = (cumsum[j + 1] - cumsum[i]) / (j - i + 1)
     result = cumsum2[j + 1] - cumsum2[i]
     result += (j - i + 1) * (mu * mu)
     result -= (2 * mu) * (cumsum[j + 1] - cumsum[i])
     return max(result, 0)
 
 
-
-@jitclass([('cumsum', float64[:]), ('cumsum2', float64[:])])
+@jitclass([("cumsum", float64[:]), ("cumsum2", float64[:])])
 class CumsumCalculator:
     def __init__(self, v):
         self.cumsum = calc_cumsum(v)
@@ -44,9 +44,9 @@ def calc(self, i, j):
 
 
 @njit([(float64[:],)], cache=USE_CACHE)
-def create_cumsum_calculator(arr): # pragma: no cover
+def create_cumsum_calculator(arr):  # pragma: no cover
     calculator = CumsumCalculator(arr)
-    print(calculator.calc(0,1))
+    print(calculator.calc(0, 1))
 
 
 @njit(cache=USE_CACHE)
@@ -58,9 +58,9 @@ def cost_of_clustering(vals, res):
     cost = 0
     for i, val in enumerate(res):
         if val != last_val:
-            cost += calc.calc(last_i, i-1)
+            cost += calc.calc(last_i, i - 1)
             last_val = val
             last_i = i
-    cost += calc.calc(last_i, len(vals)-1)
+    cost += calc.calc(last_i, len(vals) - 1)
 
-    return cost
+    return cost

fast1dkmeans/kmeans.py

@@ -6,22 +6,29 @@
 from fast1dkmeans.regularized_kmeans import __Wilber, relabel_clusters
 
 
-
-@jitclass([('cumsum', float64[:]), ('cumsum2', float64[:]), ('D', float64[:,:]), ('D_row', int64)])
-class XiaolinCalculator():
+@jitclass(
+    [
+        ("cumsum", float64[:]),
+        ("cumsum2", float64[:]),
+        ("D", float64[:, :]),
+        ("D_row", int64),
+    ]
+)
+class XiaolinCalculator:
     def __init__(self, cumsum, cumsum2, D):
         self.cumsum = cumsum
         self.cumsum2 = cumsum2
         self.D = D
-        self.D_row=0
+        self.D_row = 0
 
     def set_d_row(self, val):
-        self.D_row=val
+        self.D_row = val
 
     def calc(self, i, j):
         col = i if i < j - 1 else j - 1
         return self.D[self.D_row, col] + calc_objective(self.cumsum, self.cumsum2, j, i)
 
+
 @njit(cache=True)
 def cluster_xi(v, k):
     """Optimal quantization by matrix searching by Xiaolin Wu"""
@@ -30,28 +37,30 @@ def cluster_xi(v, k):
     n = len(v)
     D = np.empty((2, n), dtype=np.float64)
     T = np.empty((k, n), dtype=np.int64)
-    T[0,:]=0
+    T[0, :] = 0
     for j in range(n):
-        D[0,j] = cost_calculator.calc(0, j)
-    xi_calculator = XiaolinCalculator(cost_calculator.cumsum, cost_calculator.cumsum2, D)
-
+        D[0, j] = cost_calculator.calc(0, j)
+    xi_calculator = XiaolinCalculator(
+        cost_calculator.cumsum, cost_calculator.cumsum2, D
+    )
 
     n = len(v)
     row_argmins = np.empty(n, dtype=T.dtype)
     rows = np.arange(n)
     cols = np.arange(n)
     for _k in range(1, k):
-        D_row = (_k-1) % 2
+        D_row = (_k - 1) % 2
         xi_calculator.set_d_row(D_row)
         _smawk_iter(rows, cols, xi_calculator, row_argmins)
-        T[_k,:] = row_argmins
-        #print(row_argmins)
-        next_d_row =  _k % 2
+        T[_k, :] = row_argmins
+        # print(row_argmins)
+        next_d_row = _k % 2
         for i, argmin in enumerate(row_argmins):
             min_val = xi_calculator.calc(i, argmin)
             D[next_d_row, i] = min_val
     return back_track_to_get_clustering(T, n, k)
 
+
 @njit(cache=True)
 def cluster_xi_space(v, k):
     """Same as cluster_xi but with space saving technique applied"""
@@ -62,34 +71,36 @@ def cluster_xi_space(v, k):
     n = len(v)
     D = np.empty((2, n), dtype=np.float64)
     T = np.empty(n, dtype=np.int64)
-    T[:]=0
+    T[:] = 0
     for j in range(n):
-        D[0,j] = cost_calculator.calc(0, j)
-    xi_calculator = XiaolinCalculator(cost_calculator.cumsum, cost_calculator.cumsum2, D)
-
+        D[0, j] = cost_calculator.calc(0, j)
+    xi_calculator = XiaolinCalculator(
+        cost_calculator.cumsum, cost_calculator.cumsum2, D
+    )
 
     n = len(v)
     rows = np.arange(n)
     cols = np.arange(n)
     D_row = 0
     next_d_row = 0
-    for _k in range(1, k+1):
-        D_row = (_k-1) % 2
+    for _k in range(1, k + 1):
+        D_row = (_k - 1) % 2
         xi_calculator.set_d_row(D_row)
         _smawk_iter(rows, cols, xi_calculator, T)
-        #print(row_argmins)
-        next_d_row =  _k % 2
+        # print(row_argmins)
+        next_d_row = _k % 2
         for i, argmin in enumerate(T):
             min_val = xi_calculator.calc(i, argmin)
             D[next_d_row, i] = min_val
-    #print(k)
-    k_plus1_row = next_d_row #(k+1) % 2
-    k_row =  D_row #(k) % 2
-    lambda_ =  D[k_row, n-1] - D[k_plus1_row, n-1]
+    # print(k)
+    k_plus1_row = next_d_row  # (k+1) % 2
+    k_row = D_row  # (k) % 2
+    lambda_ = D[k_row, n - 1] - D[k_plus1_row, n - 1]
     assert lambda_ >= 0
     result = __Wilber(n, xi_calculator.cumsum, xi_calculator.cumsum2, lambda_)
     return relabel_clusters(result)
 
+
 @njit
 def back_track_to_get_clustering(T, n, k):
     """compute cluster assignmento of n points to k clsuters from T
@@ -103,14 +114,14 @@ def back_track_to_get_clustering(T, n, k):
         if k > 0:
             # assign the remaining n' points to k-1 clusters
             backtrack(T, n', k-1, last_n=n)
-    
+
     """
     out = np.empty(n, dtype=np.int64)
-    
+
     start = n
-    for k_ in range(k-1, -1, -1):
+    for k_ in range(k - 1, -1, -1):
         stop = start
-        start = T[k_, start-1]
-        for i in range(start, stop): # assign points to clusters
+        start = T[k_, start - 1]
+        for i in range(start, stop):  # assign points to clusters
             out[i] = k_
-    return out
+    return out

fast1dkmeans/main.py

@@ -16,19 +16,23 @@ def cluster(x, k, method="binary-search-interpolation", **kwargs):
     "Fast Exact k-Means, k-Medians and Bregman Divergence Clustering in 1D"
     """
 
-    assert method in ("binary-search-interpolation",
-                      "binary-search-normal",
-                      "dynamic-programming-kn",
-                      "dynamic-programming-space",
-                      "dynamic-programming"), f"wrong method string provided {method}"
+    assert method in (
+        "binary-search-interpolation",
+        "binary-search-normal",
+        "dynamic-programming-kn",
+        "dynamic-programming-space",
+        "dynamic-programming",
+    ), f"wrong method string provided {method}"
 
     if method == "dynamic-programming":
         method = "dynamic-programming-space"
-    
+
     x = np.squeeze(np.asarray(x))
-    assert len(x.shape)==1, "provided array is not 1d"
+    assert len(x.shape) == 1, "provided array is not 1d"
     assert k > 0, f"negative or zero values for k({k}) are not supported"
-    assert k <= len(x), f"values of k({k}) larger than the length of the provided array ({len(x)}) are not supported"
+    assert k <= len(
+        x
+    ), f"values of k({k}) larger than the length of the provided array ({len(x)}) are not supported"
 
     order = np.argsort(x)
     x = np.array(x, dtype=np.float64)[order]
@@ -41,18 +45,20 @@ def cluster(x, k, method="binary-search-interpolation", **kwargs):
         clusters = cluster_xi(x, k)
     elif method == "dynamic-programming-space":
         clusters = cluster_xi_space(x, k)
+    else:
+        assert False
     return undo_argsort(clusters, order)
-    
+
 
 def undo_argsort(sorted_arr, order):
     revert = np.empty_like(order)
-    revert[order]=np.arange(len(sorted_arr))
+    revert[order] = np.arange(len(sorted_arr))
     return sorted_arr[revert]
 
+
 @njit(cache=True)
 def undo_argsort_numba(sorted_arr, order):
     out = np.empty_like(sorted_arr)
     for i, val in enumerate(order):
         out[val] = sorted_arr[i]
     return out
-

fast1dkmeans/monge.py

@@ -1,11 +1,12 @@
 import numpy as np
 
+
 def is_monge(M):
     """Checks whether matrix M is Monge"""
-    m,n = M.shape
-    for i in range(m-1):
-        for j in range(n-1):
-            if M[i,j]+M[i+1, j+1] > M[i, j+1] + M[i+1,j]:
+    m, n = M.shape
+    for i in range(m - 1):
+        for j in range(n - 1):
+            if M[i, j] + M[i + 1, j + 1] > M[i, j + 1] + M[i + 1, j]:
                 return False
     return True
 
@@ -15,19 +16,19 @@ def _random_monge(m, n, rands):
     row-constant, column-constant, and upper-right block arrays. (This characterization was proved
     independently by Rudolf and Woeginger in 1995, Bein and Pathak in 1990, Burdyok and Trofimov
     in 1976, and possibly others.)"""
-    row_const = np.repeat(rands[-m-n:-n].reshape(m,1),repeats=n, axis=1)
-    col_const = np.repeat(rands[-n:].reshape(1,n),repeats=m, axis=0)
-    arr = row_const+col_const
+    row_const = np.repeat(rands[-m - n : -n].reshape(m, 1), repeats=n, axis=1)
+    col_const = np.repeat(rands[-n:].reshape(1, n), repeats=m, axis=0)
+    arr = row_const + col_const
     for i in range(m):
         for j in range(n):
-            arr[i:, j:] += rands[i*m+n]
+            arr[i:, j:] += rands[i * m + n]
     return np.flip(arr, axis=0)
 
 
 def random_int_monge(m, n, block_max_val, row_max_val, col_max_val):
-    """ Generates a random monge array with integer values"""
-    rands= np.empty(m*n+m+n, dtype=int)
-    rands[:m*n] = np.random.randint(block_max_val, size=m*n)
-    rands[-m-n:-n] = np.random.randint(row_max_val, size=m)
+    """Generates a random monge array with integer values"""
+    rands = np.empty(m * n + m + n, dtype=int)
+    rands[: m * n] = np.random.randint(block_max_val, size=m * n)
+    rands[-m - n : -n] = np.random.randint(row_max_val, size=m)
     rands[-n:] = np.random.randint(col_max_val, size=n)
-    return _random_monge(m, n, rands)
+    return _random_monge(m, n, rands)