Showing bitstrings as actual bitstrings in logs instead of integers (#19)

* Displaying bitstrings as actual bitstrings instead of integers

* Cleaner syntax using defaultdict

* Patch version bump

Author: bjk17

README.md

@@ -27,19 +27,19 @@ $ python -m demo.string_set
 [INFO] (CombCov) ...DONE enumerating elements! (Running time: 0.00 sec)
 [INFO] (CombCov) Total of 87 elements.
 [INFO] (CombCov) Enumeration: [1, 2, 3, 5, 8, 13, 21, 34]
-[INFO] (CombCov) Creating binary strings from rules...
-[INFO] (CombCov) Bitstring to cover: 154742504910672534362390527 
+[INFO] (CombCov) Creating binary strings and rules...
+[INFO] (CombCov) Bitstring to cover: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
 [INFO] (StringSet) Generated 16 subrules
-[INFO] (CombCov) ...DONE creating binary strings! (Running time: 0.00 sec)
+[INFO] (CombCov) ...DONE creating binary strings and rules! (Running time: 0.00 sec)
 [INFO] (CombCov) Total of 14 valid rules with 14 distinct binary strings.
 [INFO] (CombCov) Searching for a cover for ''*Av(aa) over ∑={a,b}...
 [INFO] (CombCov) Gurobi installed on system and set as solver
 [INFO] (CombCov) ...DONE searching for a cover! (Running time: 0.02 sec)
 Solution found!
- - Rule #1: ''*Av(a,b) over ∑={a,b} with bitstring 1
- - Rule #2: 'a'*Av(a,b) over ∑={a,b} with bitstring 2
- - Rule #3: 'b'*Av(aa) over ∑={a,b} with bitstring 154742431132702343545997108
- - Rule #4: 'ab'*Av(aa) over ∑={a,b} with bitstring 73777970190816393416
+ - Rule #1: ''*Av(b,a) over ∑={a,b} with bitstring 000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
+ - Rule #2: 'a'*Av(b,a) over ∑={a,b} with bitstring 000000000000000000000000000000000000000000000000000000000000000000000000000000000000010
+ - Rule #3: 'b'*Av(aa) over ∑={a,b} with bitstring 111111111111111111111000000000000011111111111110000000011111111000001111100011100110100
+ - Rule #4: 'ab'*Av(aa) over ∑={a,b} with bitstring 000000000000000000000111111111111100000000000001111111100000000111110000011100011001000
 ```
 
 

combcov/combcov.py

@@ -1,5 +1,6 @@
 import abc
 import logging
+from collections import defaultdict
 from time import time
 
 from pulp import GUROBI_CMD, PULP_CBC_CMD, LpMinimize, LpProblem, LpVariable
@@ -48,20 +49,20 @@ def _create_binary_strings_from_rules(self):
         logger.info("Creating binary strings and rules...")
         time_start = time()
 
-        string_to_cover = 2 ** len(self.elmnts_dict) - 1
-        logger.info("Bitstring to cover: {} ".format(string_to_cover))
+        bitstring_to_cover = bin(2 ** len(self.elmnts_dict) - 1)[2:]
+        logger.info("Bitstring to cover: {} ".format(bitstring_to_cover))
 
         self.rules = []
         self.bitstrings = []
-        self.bitstring_to_rules_dict = {}
+        self.bitstring_to_rules_dict = defaultdict(list)
         self.rules_to_bitstring_dict = {}
 
         for rule in self.root_object.get_subrules():
             if rule == self.root_object or rule in self.rules:
                 rule_is_good = False
             else:
                 rule_is_good = True
-                binary_string = 0
+                binary_number = 0
 
             for elmnt_size in range(self.max_elmnt_size + 1):
                 if not rule_is_good:
@@ -74,19 +75,18 @@ def _create_binary_strings_from_rules(self):
                         break
                     else:
                         seen_elmnts.add(elmnt)
-                        binary_string += 2 ** (self.elmnts_dict[elmnt])
+                        binary_number += 2 ** (self.elmnts_dict[elmnt])
 
             if rule_is_good:
+                binary_string = "{:0>{}}".format(
+                    bin(binary_number)[2:], len(self.elmnts_dict))
+
                 self.rules.append(rule)
+                self.bitstrings.append(binary_string) if \
+                    binary_string not in self.bitstrings else self.bitstrings
+                self.bitstring_to_rules_dict[binary_string].append(rule)
                 self.rules_to_bitstring_dict[rule] = binary_string
 
-                # ToDo: Use defaultdict for more readable syntax
-                if binary_string not in self.bitstring_to_rules_dict:
-                    self.bitstrings.append(binary_string)
-                    self.bitstring_to_rules_dict[binary_string] = [rule]
-                else:
-                    self.bitstring_to_rules_dict[binary_string].append(rule)
-
         time_end = time()
         elapsed_time = time_end - time_start
 
@@ -116,7 +116,7 @@ def _solve(self):
 
         for i in range(len(self.elmnts_dict)):  # nr. of equations
             constraint = sum(
-                int((self.bitstrings[j] & (1 << i)) != 0) * X[j]
+                int(self.bitstrings[j][-i]) * X[j]
                 for j in range(len(self.bitstrings))
             )  # nr. of variables x_j
             problem += constraint == 1

setup.py

@@ -11,7 +11,7 @@ def read(fname):
 
 setup(
     name="CombCov",
-    version="0.4.0",
+    version="0.4.1",
     author="Permuta Triangle",
     author_email="permutatriangle@gmail.com",
     description="Searching for combinatorial covers.",