report added, img added, minor fixes

Author: VirtualRoyalty

StringSearching.ipynb

@@ -8,6 +8,8 @@ class BoyerMooreHorspool(Algorithm):
     def __init__(self, reference):
  #       reference = reference.translate(reference.maketrans('', '', ascii_letters))
         self.reference = reference
+        self.n_operations = 0
+
 
     @property
     def name(self):
@@ -17,30 +19,33 @@ def set_candidate(self, candidate, **params):
         self.candidate = candidate
 
     def set_skip_table(self):
-        len_reference = len(self.reference)
-        len_candidate = len(self.candidate)
-        if len_candidate > len_reference:
-            print("Error: len candidate > len references {} > {}.".format(len_candidate, len_reference))
+        len_ref = len(self.reference)
+        len_can = len(self.candidate)
+        if len_can > len_ref:
+            print("Error: len candidate > len references {} > {}." \
+                              .format(len_can, len_ref))
             return -1
 
-        self.table_skip = defaultdict(lambda: len_candidate) 
+        self.table_skip = defaultdict(lambda: len_can)
+
+        for offset in range(len_can - 1):
+            self.table_skip[ord(self.candidate[offset])] = len_can - offset - 1
 
-        for offset in range(len_candidate - 1):
-            self.table_skip[ord(self.candidate[offset])] = len_candidate - offset - 1
-        
     def search(self, multiple_search=False) -> list:
         self.set_skip_table()
 
-        len_reference = len(self.reference)
-        len_candidate = len(self.candidate)
+        len_ref = len(self.reference)
+        len_can = len(self.candidate)
 
         offset_lst = []
-        offset = len_candidate - 1
+        offset = len_can - 1
 
-        while offset < len_reference:
-            j = len_candidate - 1
+        while offset < len_ref:
+            j = len_can - 1
             i = offset
+            self.n_operations += 1
             while j >= 0 and self.reference[i] == self.candidate[j]:
+                self.n_operations += 1
                 j -= 1
                 i -= 1
             if j == -1:

algorithm/boyer_moore_horspool.py

@@ -8,73 +8,74 @@ class KnuthMorrisPratt(Algorithm):
     def __init__(self, reference):
         # reference = reference.translate(reference.maketrans('', '', ascii_letters))
         self.reference = reference
+        self.n_operations = 0
+
 
     @property
     def name(self):
         return 'Knuth-Morris-Pratt'
-    
+
     def set_candidate(self, candidate, **params):
         self.candidate = candidate
 
     def search(self, multiple_search=False) -> list:
         """Return the lowest index of T at which substring P begins (or else -1)."""
-        len_reference = len(self.reference)
-        len_candidate = len(self.candidate)
-        if len_candidate > len_reference:
-            print("Error: len candidate > len references {} > {}.".format(len_candidate, len_reference))
+        len_ref = len(self.reference)
+        len_can = len(self.candidate)
+
+        if len_can > len_ref:
+            print("Error: len candidate > len references {} > {}.".format(len_can, len_ref))
             return -1
-         # create lps[] that will hold the longest prefix suffix
+        # create lps[] that will hold the longest prefix suffix
         # values for pattern
-        self.lps = [0] * len_candidate
+        self.lps = [0] * len_can
         j = 0  # index for pat[]
 
-        # Preprocess the pattern (calculate lps[] array)
+        # Preprocess the pattern
         self.computeLPSArray()
-        
         offset_lst = []
-        
+
         i = 0  # index for txt[]
-        while i < len_reference:
+        while i < len_ref:
+
+            self.n_operations += 1
             if self.candidate[j] == self.reference[i]:
                 i += 1
                 j += 1
 
-            if j == len_candidate:
+
+            if j == len_can:
+                self.n_operations += 1
                 offset_lst.append(i - j)
                 j = self.lps[j - 1]
-                if (not multiple_search): 
+                if (not multiple_search):
                     return offset_lst
             # mismatch after j matches
-            elif i < len_reference and self.candidate[j] != self.reference[i]:
-                # Do not match lps[0..lps[j-1]] characters,
-                # they will match anyway
+            elif i < len_ref and self.candidate[j] != self.reference[i]:
+                self.n_operations += 1
                 if j != 0:
                     j = self.lps[j - 1]
                 else:
                     i += 1
         return offset_lst
-        
+
     def computeLPSArray(self):
-        len_candidate = len(self.candidate)
+        len_can = len(self.candidate)
 
-        length = 0  # length of the previous longest prefix suffix
+        length = 0
 
-        self.lps[0] = 0  # lps[0] is always 0
+        self.lps[0] = 0
         i = 1
 
-        # the loop calculates lps[i] for i = 1 to M-1
-        while i < len_candidate:
+        while i < len_can:
+            self.n_operations += 1
             if self.candidate[i] == self.candidate[length]:
                 length += 1
                 self.lps[i] = length
                 i += 1
             else:
                 if length != 0:
-                    # This is tricky. Consier the example AAACAAAA
-                    # and i = 7
                     length = self.lps[length - 1]
-
-                    # Also, note that we do not increment i here
                 else:
                     self.lps[i] = 0
                     i += 1

algorithm/knuth_morris_pratt.py

@@ -8,6 +8,7 @@ def __init__(self, reference):
         self.reference     = reference
         self.n_operations  = 0
 
+
     @property
     def name(self):
         return 'Brute Force'
@@ -21,13 +22,13 @@ def set_candidate(self, candidate, **params):
 
     def search(self, multiple_search=False) -> list:
         offset_lst    = []
-        len_reference = len(self.reference)
-        len_candidate = len(self.candidate)
-        for offset in range(len_reference - len_candidate):
+        len_ref = len(self.reference)
+        len_can = len(self.candidate)
+        for offset in range(len_ref -len_can + 1):
             i = 0
             while self.reference[offset + i] == self.candidate[i]:
                 self.n_operations += 1
-                if (i + 1) == len_candidate:
+                if (i + 1) == len_can:
                     offset_lst.append(offset)
                     if not multiple_search:
                         return offset_lst

algorithm/naive.py

@@ -7,9 +7,11 @@ class RabinKarp(Algorithm):
 
     def __init__(self, reference, hash_function=hash):
         self.reference     = reference
+        self.n_operations = 0
         self.hash_function = hash_function
         self.n_operations  = 0
 
+
     @property
     def name(self):
         return 'Rabin-Karp'
@@ -41,23 +43,26 @@ def search(self, multiple_search=False)-> list:
 
         for i in range(len_ref-len_can+1):
 
+           self.n_operations += 1
+
            if self.c == self.r:
                match = True
                for j in range(len_can):
+                   self.n_operations += 1
                    if self.candidate[j] != self.reference[i+j]:
                        match = False
                        break
                if match:
                    offset_lst.append(i)
                    if not multiple_search:
-                       return offset
+                       return [i]
 
            if i < len_ref - len_can:
                self.r =  (self.r - self.h * ord(self.reference[i]))
                self.r %= self.q
                self.r =  (self.r * self.d + ord(self.reference[i+len_can]))
                self.r %= self.q
-               self.r =  (self.r + self.q) % self.q
+               # self.r =  (self.r + self.q) % self.q
 
         return offset_lst
 
@@ -72,6 +77,7 @@ def search_pyhash(self, multiple_search=False) -> list:
         for offset in range(int(np.ceil(len_ref / len_can))):
             reference_hash = hash(self.reference[offset:(offset + len_can)])
             if reference_hash == candidate_hash:
+                self.n_operations += 1
                 i = 0
                 while self.reference[offset + i] == self.candidate[i]:
                     self.n_operations += 1

algorithm/rabin_karp.py

@@ -26,6 +26,7 @@ def generate_stat(algorithms,
                   gen_string,
                   dictionary, reference_len, candidate_len,
                   n_observations,
+                  multiple_search=True,
                   **params):
 
     # sanity checks
@@ -41,6 +42,7 @@ def generate_stat(algorithms,
                      'preprocessing': [],
                      'execution':     [],
                      'observation':   [],
+                     'n_operations':  [],
                      'indexes':       []
                    }
 
@@ -59,7 +61,7 @@ def generate_stat(algorithms,
                 preprocess = datetime.now() - start_time
 
                 start_time = datetime.now()
-                indexes = alg.search(multiple_search=True)
+                indexes = alg.search(multiple_search=multiple_search)
                 execution = datetime.now() - start_time
 
                 info_dct['algorithm']     += [alg.name]
@@ -68,6 +70,7 @@ def generate_stat(algorithms,
                 info_dct['preprocessing'] += [preprocess.total_seconds()]
                 info_dct['execution']     += [execution.total_seconds()]
                 info_dct['observation']   += [observation]
+                info_dct['n_operations']  += [alg.n_operations]
                 info_dct['indexes']       += [str(indexes)]
 
     return pd.DataFrame.from_dict(info_dct)
@@ -79,6 +82,7 @@ def generate_stat_for_benchmarks(algorithms,
                                   files_t,
                                   path_to_benchmarks,
                                   n_observations=1,
+                                  multiple_search=True,
                                   **params):
 
     assert len(files_w) == len(files_t)
@@ -94,6 +98,7 @@ def generate_stat_for_benchmarks(algorithms,
                      'preprocessing': [],
                      'execution':     [],
                      'observation':   [],
+                     'n_operations':  [],
                      'indexes':       []
                    }
     for observation in range(n_observations):
@@ -117,7 +122,7 @@ def generate_stat_for_benchmarks(algorithms,
                 preprocess = datetime.now() - start_time
 
                 start_time = datetime.now()
-                indexes    = alg.search(multiple_search=True)
+                indexes    = alg.search(multiple_search=multiple_search)
                 execution  = datetime.now() - start_time
 
                 info_dct['algorithm']     += [alg.name]
@@ -127,6 +132,7 @@ def generate_stat_for_benchmarks(algorithms,
                 info_dct['preprocessing'] += [preprocess.total_seconds()]
                 info_dct['execution']     += [execution.total_seconds()]
                 info_dct['observation']   += [observation]
+                info_dct['n_operations']  += [alg.n_operations]
                 info_dct['indexes']       += [str(indexes)]
     return pd.DataFrame.from_dict(info_dct)
 
@@ -148,7 +154,7 @@ def get_plots(stat_df,
                          oy - 2 * oy_std,
                          oy + 2 * oy_std,
                          color=p[0].get_color(), alpha=0.3,
-                         label='Confidence interval of 68% ' + alg)
+                         label='Confidence interval of 68% '+alg)
     plt.title(title)
     plt.xlabel('Reference string length')
     plt.ylabel('Time, seconds ')