Refactored and Optimized BWT

Author: 3omar-mostafa

Compressors/BWT/BWT.h

@@ -4,8 +4,9 @@
 #include "../../Utils/BinaryIO.h"
 #include "SuffixArray.h"
 #include <algorithm>
-#include <list>
 #include <cstdint>
+#include <deque>
+#include <bit_string.h>
 
 /**
  * Burrows - Wheeler Transform
@@ -19,30 +20,24 @@ class BWT {
     static void encode(const std::string& filename, const std::string& outputFileName) {
 
         std::string toBeEncoded = BinaryIO::readString(filename);
-
-        toBeEncoded += '\0';
+        toBeEncoded += '\0'; // Last char must be the smallest of all
 
         std::vector<uint32_t> suffixArray = SuffixArray::buildSuffixArray(toBeEncoded);
 
         std::string bwt = generateBWT(toBeEncoded, suffixArray);
 
         remove(outputFileName.c_str()); // Remove Output File If Exists
+        BinaryIO::write(outputFileName, bit_string::from_uint_32(originalIndex));
         BinaryIO::write(outputFileName, bwt);
-        BinaryIO::write(outputFileName, originalIndex);
 
     }
 
     static void decode(const std::string& filename, const std::string& outputFileName) {
 
-        std::string bwt = BinaryIO::readString(filename);
-
-        std::string index;
-        for (int i = 0; i < sizeof(originalIndex); ++i) {
-            index.insert(0, 1, bwt.back());
-            bwt.pop_back();
-        }
+        // Original Index is the first 4 bytes of the file
+        originalIndex = BinaryIO::readBitString(filename, 0, sizeof(originalIndex)).to_uint_32();
+        std::string bwt = BinaryIO::readString(filename, sizeof(originalIndex));
 
-        originalIndex = (uint32_t) Converter::string_ToInt64(index);
         std::string inverseBWT = BWT::invertBWT(bwt, originalIndex);
         inverseBWT.pop_back(); // remove '\0' which was added at encoding
 
@@ -53,9 +48,28 @@ class BWT {
 
 
 private:
-    static void computeLeftShift(std::list<int>& list, int index, int leftShift[]) {
-        leftShift[index] = list.front();
-        list.pop_front();
+
+    static std::vector<uint32_t> computeLeftShift(const std::string& bwt) {
+
+        // Each element is a list of all indices the this element appeared at in bwt
+        // example: symbolsIndicesList[65] contains all indices that letter 'A' appears at
+        std::deque<uint32_t> symbolsIndicesList[256]; // 256 is the length all symbols as we us byte it is 256 maximum
+        for (int i = 0; i < bwt.length(); i++) {
+            symbolsIndicesList[(uint8_t) bwt[i]].push_back(i);
+        }
+
+        std::string sortedBWT = bwt;
+        std::sort(sortedBWT.begin(), sortedBWT.end(), unsignedCharsCompare);
+
+        std::vector<uint32_t> leftShift(bwt.length());
+        // Computes Left Shift
+        for (int i = 0; i < bwt.length(); i++) {
+            std::deque<uint32_t>& symbolIndices = symbolsIndicesList[(uint8_t) sortedBWT[i]];
+            leftShift[i] = symbolIndices.front();
+            symbolIndices.pop_front();
+        }
+
+        return leftShift;
     }
 
     // Generate Burrows - Wheeler Transform of given text
@@ -87,41 +101,18 @@ class BWT {
     }
 
     static std::string invertBWT(const std::string& BWT, long long index) {
-        int length = BWT.length();
-        std::string sortedBWT = BWT;
-        int* leftShift = new int[length];
 
-        // Sorts the characters of BWT[] alphabetically
-        std::sort(sortedBWT.begin(), sortedBWT.end(), unsignedCharsCompare);
-
-        // Array of pointers that act as head nodes
-        // to linked lists created to compute leftShift[]
-        std::list<int> arr[256]; // 256 is the length all symbols as we us byte it is 256 maximum
-
-        // Takes each distinct character of BWT[] as head
-        // of a linked list and appends to it the new node
-        // whose data part contains index at which
-        // character occurs in BWT[]
-        for (int i = 0; i < length; i++) {
-            arr[(uint8_t) BWT[i]].push_back(i);
-        }
-
-        // Takes each distinct character of sorted_arr[] as head
-        // of a linked list and finds leftShift[]
-        for (int i = 0; i < length; i++) {
-            computeLeftShift(arr[(uint8_t) sortedBWT[i]], i, leftShift);
-        }
+        std::vector<uint32_t> leftShift = computeLeftShift(BWT);
 
         std::string inverseBWT;
+        inverseBWT.reserve(BWT.length());
 
         // Decodes the bwt
-        for (int i = 0; i < length; i++) {
+        for (int i = 0; i < BWT.length(); i++) {
             index = leftShift[index];
             inverseBWT += BWT[index];
         }
 
-        delete[] leftShift;
-
         return inverseBWT;
     }