complete lz77 compress algorithm

Author: 15045120

build.gradle

@@ -26,7 +26,7 @@ tasks.withType(JavaCompile) { options.encoding = "UTF-8" }
 
 group = 'com.github.myibu'
 archivesBaseName = "algorithm-java"
-version = "1.0.0b"
+version = "1.0.0c"
 
 repositories {
     mavenCentral()

readme.md

@@ -49,7 +49,7 @@ Reference to: [MersenneTwister.pdf](./docs/HoffmanAndGolombCoding.pdf)
 <dependency>
   <groupId>com.github.myibu</groupId>
   <artifactId>algorithm-java</artifactId>
-  <version>1.0.0b</version>
+  <version>1.0.0c</version>
 </dependency>
 ```
 

src/main/java/com/github/myibu/algorithm/compress/LZ77Compressor.java

@@ -3,6 +3,8 @@
 import com.github.myibu.algorithm.data.Bits;
 import com.github.myibu.algorithm.endode.GolombEncoder;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -74,41 +76,40 @@ public int compress(byte[] in_data, int in_len, byte[] out_data) {
             }
             int llStart = sEnd - 1, rrStart = 0, llEnd = 0, rrEnd = (lp = lEnd);
             int minMatched = 1, minIndex = 0;
-            while (llStart >= 0) {
-                int matched = 0, left = llStart, right = rrStart;
-                while (left >= 0 && right < rrEnd && sBuf[left--] == lWindow[right++]) {
+            for (int i = llStart; i >= 0; i--) {
+                int matched = 0, left = i, right = rrStart;
+                while (left >= llEnd && right < rrEnd && sBuf[left--] == lWindow[right++]) {
                     matched++;
                 }
                 if (matched >= minMatched) {
-                    minIndex = llStart;
+                    minIndex = i;
                     minMatched = matched;
                 }
-                llStart--;
             }
+            int lWindowLen = lWindow.length;
             // only one byte in window, set tuple to (0, 0, lWindow[0])
-            if (lWindow.length == 1) {
+            if (lWindowLen == 1) {
                 minIndex = 0;
             }
             // matched
             if (minIndex > 0) {
-                // 匹配到5个怎么编码
-                tuples.add(Arrays.asList( minIndex + 1, minMatched, (int)lWindow[minMatched]));
-                sp += (minMatched + 1);
-                ip += (minMatched + 1);
+                tuples.add(Arrays.asList( minIndex + 1, minMatched, (minMatched == lWindowLen) ? null : (int)lWindow[minMatched]));
+                sp += ((minMatched == lWindowLen) ? minMatched : (minMatched + 1));
+                ip += ((minMatched == lWindowLen) ? minMatched : (minMatched + 1));
             } else {
                 sp++;
                 ip++;
                 tuples.add(Arrays.asList(0, 0, (int)lWindow[0]));
             }
             if (isDebug) {
-                System.out.println("Txt=" + new String() + new String(in_data) + ", SearchBuffer="
+                System.out.println(", SearchBuffer="
                         +  new StringBuilder(new String(sBuf)).reverse().toString() + ", LookaheadWindow=" + new String(lWindow)
                         + " | " + tuples.get(tuples.size()-1)/* + " | " + (char)(tuples.get(tuples.size()-1).get(2).intValue())*/);
             }
         }
         int compressedLen = doEncode(tuples, out_data);
         if (isDebug) {
-            System.out.println("after encode: compressed rate=" + (compressedLen * 1.0 / in_len));
+            System.out.println("after encode: compressed rate=" + new BigDecimal(compressedLen * 100.0 / in_len).setScale(2, RoundingMode.HALF_UP) + "%");
         }
         return compressedLen;
     }
@@ -122,8 +123,11 @@ private int doEncode(List<List<Integer>> tuples, byte[] out_data) {
             bits.append(bits1);
             Bits bits2 = encoder.encode(tuple.get(1), l);
             bits.append(bits2);
-            Bits bits3 = Bits.ofByte((byte)tuple.get(2).intValue());
-            bits.append(bits3);
+            Bits bits3 = new Bits();
+            if (tuple.get(2) != null) {
+                bits3 = Bits.ofByte((byte) tuple.get(2).intValue());
+                bits.append(bits3);
+            }
             if (isDebug) {
                 System.out.println(tuple + " encoded result: " + "("+ bits1 + ", "+ bits2 + ", "+ bits3 + ")");
             }
@@ -181,12 +185,16 @@ public int decompress(byte[] in_data, int in_len, byte[] out_data) {
                     }
                 }
             }
-            if (length == -1 || ip+8 > bits.length()) {
+            if (length == -1 ) {
                 break;
             }
-            int symbol = (int)bits.subBits(ip, ip+8).toByte();
-            tuples.add(Arrays.asList(offset, length, symbol));
-            ip += 8;
+            if (length != l && ip + 8 <= bits.length()) {
+                int symbol = (int) bits.subBits(ip, ip + 8).toByte();
+                tuples.add(Arrays.asList(offset, length, symbol));
+                ip += 8;
+            } else {
+                tuples.add(Arrays.asList(offset, length, null));
+            }
         }
         if (isDebug) {
             System.out.println("decode tuples=" + tuples);
@@ -197,17 +205,35 @@ public int decompress(byte[] in_data, int in_len, byte[] out_data) {
     private int doDecode(List<List<Integer>> tuples, byte[] out_data) {
         Bits seq = new Bits();
         for (List<Integer> tuple: tuples) {
-            int offset = tuple.get(0), length = tuple.get(1), symbol = tuple.get(2);
-            Bits sb = Bits.ofByte((byte) symbol);
-            if (offset == 0) {
-                seq.append(sb);
+            int offset = tuple.get(0), length = tuple.get(1);
+            if (tuple.get(2) != null) {
+                int symbol = tuple.get(2);
+                Bits sb = Bits.ofByte((byte) symbol);
+                if (offset == 0) {
+                    seq.append(sb);
+                    if (isDebug) {
+                        System.out.println(tuple + ", seq=" + new String(seq.toByteArray()));
+                    }
+                } else {
+                    int start = seq.byteLength() < s ? seq.byteLength() - offset: s - offset;
+                    int used = seq.byteLength() < s ? 0 : seq.byteLength() - s;
+                    seq.append(seq.subBits((used + start) * 8, (used + start + length) * 8)).append(sb);
+                    if (isDebug) {
+                        System.out.println(tuple + ", seq=" + new String(seq.toByteArray()));
+                    }
+                }
             } else {
                 int start = seq.byteLength() < s ? seq.byteLength() - offset: s - offset;
                 int used = seq.byteLength() < s ? 0 : seq.byteLength() - s;
-                seq.append(seq.subBits((used + start) * 8, (used + start + length) * 8)).append(sb);
-//                System.out.println("start=" + start + ", used=" + used + ", length=" +  length + ", seq=" + seq);
+                seq.append(seq.subBits((used + start) * 8, (used + start + length) * 8));
+                if (isDebug) {
+                    System.out.println(tuple + ", seq=" + new String(seq.toByteArray()));
+                }
             }
         }
+        if (isDebug) {
+            System.out.println("after decode, bits=" + seq);
+        }
         int len = seq.byteLength();
         for (int i = 0; i < len; i++) {
             out_data[i] = seq.getByte(i).toByte();
@@ -222,4 +248,9 @@ private int doDecode(List<List<Integer>> tuples, byte[] out_data) {
     public void setDebug(boolean isDebug) {
         this.isDebug = isDebug;
     }
+
+    public void setSL(int s, int l) {
+        this.s = s;
+        this.l = l;
+    }
 }

src/test/java/com/github/myibu/algorithm/AlgorithmTest.java

@@ -168,15 +168,14 @@ public void testLZFCompressor() {
 
     @Test
     public void testLZ77Compressor() {
-        //todo
         String txt = "abracadabradabracadabradabracadabradabracadabradabracadabradabracadabradabracadabradabracadabradabracadabrad";
         byte[] in_data = txt.getBytes(StandardCharsets.UTF_8);
         byte[] out_data = new byte[in_data.length*2];
         Compressor compressor = new LZ77Compressor();
         compressor.setDebug(true);
         int compressed = compressor.compress(in_data, in_data.length, out_data);
         byte[] compressed_data = Arrays.copyOf(out_data, compressed);
-        byte[] decompressed_data = new byte[compressed * 2];
+        byte[] decompressed_data = new byte[txt.length()];
         int decompressed = compressor.decompress(compressed_data, compressed, decompressed_data);
         Assert.assertEquals(txt,
                 new String(Arrays.copyOf(decompressed_data, decompressed), StandardCharsets.UTF_8));