complete with GolombEncoder

Author: 15045120

src/main/java/com/github/myibu/algorithm/data/Bits.java

@@ -1,10 +1,14 @@
 package com.github.myibu.algorithm.data;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
 /**
  * Bits entity
  * @author myibu
  * Created on 2021/9/14
  */
-public class Bits {
+public class Bits implements Iterable<Bit> {
     public static final int BYTE_SIZE = 8;
     public static final int SHORT_SIZE = 16;
     public static final int INT_SIZE = 32;
@@ -457,4 +461,38 @@ public String toString() {
                 .append(", used=").append(used).append("}");
         return builder.toString();
     }
+
+    @Override
+    public Iterator<Bit> iterator() {
+        return new Itr();
+    }
+
+    private class Itr implements Iterator<Bit> {
+        int cursor = 0;
+        int lastRet = -1;
+
+        @Override
+        public boolean hasNext() {
+            return cursor != length();
+        }
+
+        @Override
+        public Bit next() {
+            try {
+                int i = cursor;
+                Bit next = get(i);
+                lastRet = i;
+                cursor = i + 1;
+                return next;
+            } catch (IndexOutOfBoundsException e) {
+                throw new NoSuchElementException();
+            }
+        }
+    }
+
+    public Bit get(int index) {
+        if (index < 0 || index >= used)
+            throw new IndexOutOfBoundsException();
+        return table[index];
+    }
 }

src/main/java/com/github/myibu/algorithm/endode/GolombEncoder.java

@@ -1,5 +1,6 @@
 package com.github.myibu.algorithm.endode;
 
+import com.github.myibu.algorithm.data.Bit;
 import com.github.myibu.algorithm.data.Bits;
 
 /**
@@ -10,7 +11,7 @@
  */
 public class GolombEncoder implements Encoder {
     /**
-     *
+     * encode n to binary bits based on argument m
      * @param n the value to encode
      * @param m m, like 5
      * @return the length of encoded bits
@@ -23,7 +24,7 @@ public Bits encode(int n, int m) {
         int r = n % m;
         int k = (int)(Math.ceil(Math.log(m) / Math.log(2)));
         if ((m & 0x01) == 0) {
-            return bits.append(encodeToStandardBinary(r, k));
+            return bits.append(encodeToBinary(r, k));
         } else {
             // truncated binary encoding
             if (r < Math.pow(2, k) - m) {
@@ -34,10 +35,6 @@ public Bits encode(int n, int m) {
         }
     }
 
-    private Bits encodeToStandardBinary(int x, int len) {
-        return encodeToBinary(x, len);
-    }
-
     private Bits encodeToTruncatedBinary(int x, int n) {
         // Set k = floor(log2(n)), i.e., k such that 2^k <= n < 2^(k+1).
         int k = 0, t = n;
@@ -60,4 +57,55 @@ private Bits encodeToBinary(int x, int len) {
         while (s.length() < len)  s = Bits.ofZero().append(s);
         return s;
     }
+
+    /**
+     * decode binary bits to n
+     * @param bits encoded binary bits
+     * @param m m, like 5
+     * @return decoded value
+     */
+    public int decode(Bits bits, int m) {
+        // To decode, read the first k bits.
+        // If they encode a value less than u, decoding is complete.
+        // Otherwise, read an additional bit and subtract u from the result.
+        boolean isRStart = false;
+        Bits qb = new Bits(), rb = new Bits();
+        for (Bit bit: bits) {
+            if (!isRStart && bit == Bit.ZERO) {
+                isRStart = true;
+                continue;
+            }
+            if (!isRStart) {
+                qb.append(bit);
+            } else {
+                rb.append(bit);
+            }
+        }
+        int q = qb.length();
+        int r = 0;
+        if ((m & 0x01) == 0) {
+            r = encodeToBinary(rb);
+        } else {
+            r = decodeTruncatedBinary(rb, m);
+        }
+        return q * m + r;
+    }
+
+    public int decodeTruncatedBinary(Bits bits, int m) {
+        // Set k = floor(log2(n)), i.e., k such that 2^k <= n < 2^(k+1).
+        int k = 0, t = m;
+        while (t > 1) { k++;  t >>= 1; }
+        // Set u to the number of unused codewords = 2^(k+1) - n.
+        int u = (1 << k+1) - m;
+        int x = encodeToBinary(bits);
+        return (x < u) ? x : (x - u);
+    }
+
+    private int encodeToBinary(Bits bits) {
+        int x = 0;
+        for (int i = 0; i < bits.length(); i++) {
+            x += (bits.get(i).value() << (bits.length() - i - 1));
+        }
+        return x;
+    }
 }

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

@@ -20,7 +20,9 @@
 import org.junit.Test;
 
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Set;
 
 public class AlgorithmTest {
@@ -177,12 +179,16 @@ public void testLZ77Compressor() {
 
     @Test
     public void testGolombEncoder() {
-        int m = 5;
+        int m = 4;
         GolombEncoder encoder = new GolombEncoder();
-        System.out.println(5 + "= "  + encoder.encode(5, m));
-        System.out.println(6 + "= "  + encoder.encode(6, m));
-        System.out.println(7 + "= "  + encoder.encode(7, m));
-        System.out.println(8 + "= "  + encoder.encode(8, m));
-        System.out.println(9 + "= "  + encoder.encode(9, m));
+        List<Bits> encodeList = new ArrayList<>();
+        for (int i = 1; i <= 9; i++) {
+            encodeList.add(encoder.encode(i, m));
+        }
+        for (int i = 0; i < encodeList.size(); i++) {
+            Bits bits = encodeList.get(i);
+            System.out.println("encode " + (i+1) + " => " + bits);
+            System.out.println("decode " + bits + " => " + encoder.decode(bits, m));
+        }
     }
 }