Refactoring code

Move tests to test folder
Move source code to source folder (reversal_sort)

main.py

 import csv
-import SBR
-import AdaptiveTBS
-import TripartiteBinarySort
 from itertools import permutations
 from math import factorial
 import random
 
+from reversal_sort import SBR, adaptive_tbs, tripartite_binary_sort
+
 """
 Collects routing time data for the algorithms GDC(TBS), GDC(ATBS), and OES.
 Spits out the data into csv files in the "/data/" directory. 
@@ -118,7 +117,7 @@ def new_rand_perms_file(alglist, algnames, nlist, count):
 
 def main(NUM_PERMS_PER_LENGTH, LENGTH_FROM, LENGTH_TO):
     algnames = ['OES', 'GDC(TBS)', 'GDC(ATBS)']
-    algs = [SBR.odd_even_sort, TripartiteBinarySort.GDC_TBS, AdaptiveTBS.GDC_ATBS]
+    algs = [SBR.odd_even_sort, tripartite_binary_sort.GDC_TBS, adaptive_tbs.GDC_ATBS]
     new_rand_perms_file(algs, algnames, list(range(LENGTH_FROM,LENGTH_TO + 1)), NUM_PERMS_PER_LENGTH)
 
 
@@ -127,5 +126,8 @@ if __name__ == "__main__":
     import sys
     for line in sys.stdin:
         perm = [int(el) for el in line.split()]
-        reversals = TripartiteBinarySort.permutationsort_divideconquer_tbs(perm)
+        # Check if is permutation
+        if set(range(0, len(perm))) != set(perm):
+            raise ValueError(f"Given permutation does not contain all elements in [0,{len(perm)-1}].")
+        reversals = tripartite_binary_sort.routing_divideconquer_tbs(perm)
         print(reversals) # TODO: Implement pretty print
\ No newline at end of file

poetry.lock

+[[package]]
+name = "autopep8"
+version = "1.5.5"
+description = "A tool that automatically formats Python code to conform to the PEP 8 style guide"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+pycodestyle = ">=2.6.0"
+toml = "*"
+
+[[package]]
+name = "pycodestyle"
+version = "2.6.0"
+description = "Python style guide checker"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+category = "dev"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[metadata]
+lock-version = "1.1"
+python-versions = "^3.8"
+content-hash = "69f8da9bda3c52f2aeef6c0b305a37c17ebe7dbf3e7e7433d3c962a6fa6f07ed"
+
+[metadata.files]
+autopep8 = [
+    {file = "autopep8-1.5.5-py2.py3-none-any.whl", hash = "sha256:9e136c472c475f4ee4978b51a88a494bfcd4e3ed17950a44a988d9e434837bea"},
+    {file = "autopep8-1.5.5.tar.gz", hash = "sha256:cae4bc0fb616408191af41d062d7ec7ef8679c7f27b068875ca3a9e2878d5443"},
+]
+pycodestyle = [
+    {file = "pycodestyle-2.6.0-py2.py3-none-any.whl", hash = "sha256:2295e7b2f6b5bd100585ebcb1f616591b652db8a741695b3d8f5d28bdc934367"},
+    {file = "pycodestyle-2.6.0.tar.gz", hash = "sha256:c58a7d2815e0e8d7972bf1803331fb0152f867bd89adf8a01dfd55085434192e"},
+]
+toml = [
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
+]

pyproject.toml

+[tool.poetry]
+name = "reversal-sort"
+version = "0.1.0"
+description = ""
+authors = ["None"]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+
+[tool.poetry.dev-dependencies]
+autopep8 = "^1.5.5"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

AdaptiveTBS.py → reversal_sort/adaptive_tbs.py

-import SBR
 import math
-import random
-import timeit
+
+from . import SBR
 
 
 def GDC_ATBS(perm):
@@ -150,11 +149,4 @@ def sequential_permutation_sort_parallelized(perm, i, j):
     m = (i + j) // 2
     SBR.apply_revs(offsetrevs, perm)
     return offsetrevs + sequential_permutation_sort_parallelized(perm, i, m) + \
-           sequential_permutation_sort_parallelized(perm, m + 1, j)
-
-
-if __name__ == '__main__':
-    print(GDC_ATBS([8,7,6,5,4,3,2,1]))
-
-
-
+           sequential_permutation_sort_parallelized(perm, m + 1, j)
\ No newline at end of file

reversal_sort/routing.py

+from . import SBR, tripartite_binary_sort
+
+def GDC_TBS(perm):
+    """
+    Returns the cost to sort perm using TBS as the binary sorting sequence.
+    (GenericDivideConquer_TripartiteBinarySort)
+    """
+    revlist = routing_divideconquer_tbs(perm, 0, len(perm) - 1)
+    cost = SBR.compress_reversals(revlist, len(perm)) / 3
+    return cost
+
+def perm_to_01(L, i, j):
+    """
+    TUrns a permutation L[i:j] into a permutation of 0s and 1s, where L[i] is 0 if it is
+    less than the median and L[i] is 1 if it is greater than the median
+    """
+    subseq = L[i:j + 1]
+    sorted_subseq = sorted(subseq)
+    median = (j - i) // 2
+    return L[:i] + [int(sorted_subseq.index(k) > median) for k in subseq] + L[j + 1:]
+
+def routing_divideconquer_tbs(L, i=None, j=None):
+    """
+    Sorts the given permutations L from index i to j (inclusive) using a divide and conquer approach. Returns a list of
+    reversals used to perform the sort.
+    """
+    # Set default params
+    if i == None:
+        i = min(L)
+    if j == None:
+        j = max(L)
+
+    if i == j:
+        return []
+    T = perm_to_01(L, i, j)
+    revs = tripartite_binary_sort.tripartite_binary_sort(T, i, j)
+    m = (i + j) // 2
+    SBR.apply_revs(revs, L)
+    return revs + routing_divideconquer_tbs(L, i, m) + routing_divideconquer_tbs(L, m + 1, j)

TripartiteBinarySort.py → reversal_sort/tripartite_binary_sort.py

-import SBR
-import math
-import itertools
-import random
-from itertools import permutations
-
 """
-TripartiteBinarySort.py -- Implementation of the TBS algorithm for sorting bitstrings and permutations,
+Implementation of the TBS algorithm for sorting bitstrings and permutations,
 along with a couple testing/analysis functions
 """
+import math
 
-def GDC_TBS(perm):
-    """
-    Returns the cost to sort perm using TBS as the binary sorting sequence.
-    (GenericDivideConquer_TripartiteBinarySort)
-    """
-    revlist = permutationsort_divideconquer_tbs(perm, 0, len(perm) - 1)
-    cost = SBR.compress_reversals(revlist, len(perm)) / 3
-    return cost
-
+from . import SBR
 
 def tripartite_binary_sort(T, i, j):
     """
@@ -63,37 +50,6 @@ def zero_one_indices(T, i, j):
             break
     return oneind, zerind
 
-def perm_to_01(L, i, j):
-    """
-    TUrns a permutation L[i:j] into a permutation of 0s and 1s, where L[i] is 0 if it is
-    less than the median and L[i] is 1 if it is greater than the median
-    """
-    subseq = L[i:j + 1]
-    sorted_subseq = sorted(subseq)
-    median = (j - i) // 2
-    return L[:i] + [int(sorted_subseq.index(k) > median) for k in subseq] + L[j + 1:]
-
-def permutationsort_divideconquer_tbs(L, i=None, j=None):
-    """
-    Sorts the given permutations L from index i to j (inclusive) using a divide and conquer approach. Returns a list of
-    reversals used to perform the sort.
-    """
-    # Set default params
-    if i == None:
-        i = min(L)
-    if j == None:
-        j = max(L)
-
-    if i == j:
-        return []
-    T = perm_to_01(L, i, j)
-    revs = tripartite_binary_sort(T, i, j)
-    m = (i + j) // 2
-    SBR.apply_revs(revs, L)
-    return revs + permutationsort_divideconquer_tbs(L, i, m) + permutationsort_divideconquer_tbs(L, m + 1, j)
-
-
-
 def all_binary_lists_equal(n):
     """
     generates list of lists, where each list is a binary sequence of length n,
@@ -116,40 +72,4 @@ def all_binary_lists_equal(n):
 
     lis = []
     blep(n, [], 0, 0, lis)
-    return lis
-
-def test_binary_sort():
-    """
-    Testing correctness of sorting bitstrings with TBS.
-    """
-    wrong = 0
-    for i in range(1000):
-      l  = [0]*random.randint(100,200) + [1]*random.randint(100,200)
-      random.shuffle(l)
-      before = l.copy()
-      #print(before)
-      tripartite_binary_sort(l, 0 , len(l)-1)
-      #print(l, '\n')
-      if l != sorted(before):
-          print("failed")
-    print("passed")
-
-def test_perm_sort():
-    """
-    Testing correctness of sorting permutations with TBS as
-    bitstring sorting subroutine. 
-    Returns number
-    """
-    wrong = 0
-    n = 1000
-    for ct in range(n):
-        L = list(range(1,random.randint(5, 200)))
-        random.shuffle(L)
-        before = L.copy()
-        permutationsort_divideconquer_tbs(L,0,len(L)-1)
-        #print(before, '\n', L, '\n')
-        if L != sorted(before):
-            print("failed")
-            return 
-    print("passed")
-
+    return lis
\ No newline at end of file

test/test_routing.py

+import random
+from reversal_sort import routing
+from unittest import TestCase
+
+class TestRourting(TestCase):
+
+    def test_perm_sort(self):
+        """
+        Testing correctness of sorting permutations with TBS as
+        bitstring sorting subroutine. 
+        Returns number
+        """
+        n = 1000
+        for ct in range(n):
+            L = list(range(1,random.randint(5, 200)))
+            random.shuffle(L)
+            before = L.copy()
+            routing.routing_divideconquer_tbs(L,0,len(L)-1)
+            self.assertEqual(sorted(before), L)
\ No newline at end of file

test/test_tripartite_binary_sort.py

+import random
+from reversal_sort import TripartiteBinarySort
+from unittest import TestCase
+
+class TestTBS(TestCase):
+
+    def test_binary_sort(self):
+        """
+        Testing correctness of sorting bitstrings with TBS.
+        """
+        for i in range(1000):
+            l = [0]*random.randint(100,200) + [1]*random.randint(100,200)
+            random.shuffle(l)
+            before = l.copy()
+            #print(before)
+            TripartiteBinarySort.tripartite_binary_sort(l, 0 , len(l)-1)
+            #print(l, '\n')
+            self.assertEqual(sorted(before), l)
\ No newline at end of file