new file: Encoding/variable_length_run_encoding.sf

Author: trizen

Encoding/compress.sf

@@ -5,8 +5,11 @@
 # This implementation reads from STDIN and outputs to STDOUT:
 #   sidef compress.sf < input.txt > output.Z
 
-# See also:
+# Reference:
+#   Data Compression (Summer 2023) - Lecture 4 - The Unix 'compress' Program
 #   https://youtube.com/watch?v=1cJL9Va80Pk
+
+# See also:
 #   https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Welch
 
 define (

Encoding/integers_binary_encoding.sf

@@ -48,25 +48,22 @@ func encode_integers (Array integers) {
 
 func decode_integers (String str) {
 
-    func str_shift(Ref s) {
-        with ((*s).substr(0, 1)) { |t| (*s).substr!(1); t }
-    }
-
-    var count_len = str_shift(\str).ord
+    var str_fh = str.open_r(:raw)
+    var count_len = str_fh.getc.ord
     var counts = []
 
     count_len.times {
-        var b = str_shift(\str).ord
-        var l = Num(unpack('N', 4.of { str_shift(\str) }.join))
+        var b = str_fh.getc.ord
+        var l = Num(unpack('N', 4.of { str_fh.getc }.join))
         counts << [b, l] if (l > 0)
     }
 
     var chunks = []
-    var bits = str.ascii2bin
+    var bits_fh = str_fh.slurp.ascii2bin.open_r(:raw)
 
     for b,len in (counts) {
-        chunks << bits.substr(0, b*len).slices(b)...
-        bits.substr!(b*len)
+        bits_fh.read(\var chunk, len*b)
+        chunks << chunk.slices(b)...
     }
 
     chunks.map { Num(_, 2) }

Encoding/variable_length_run_encoding.sf

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby
+
+# Implementation of the Variable Length Run Encoding.
+
+# Reference:
+#   Data Compression (Summer 2023) - Lecture 5 - Basic Techniques
+#   https://youtube.com/watch?v=TdFWb8mL5Gk
+
+func VLR_encoding (String str) {
+
+    var bitstream = []
+
+    for c,v in (str.chars.run_length) {
+        bitstream << c.ascii2bin
+        if (v == 1) {
+            bitstream << '0'
+        }
+        else {
+            var t = (v-1).as_bin
+            bitstream << ('1'*t.len + '0' + t.substr(1))
+        }
+    }
+
+    bitstream.join
+}
+
+func VLR_decoding (String bitstring) {
+
+    var decoded = []
+    var bits_fh = bitstring.open_r(:raw)
+
+    while (!bits_fh.eof) {
+        var s = 8.of { bits_fh.getc }.join
+        var c = pack('B*', s)
+
+        var bit_len = 0
+        while (bits_fh.getc == '1') {
+            ++bit_len
+        }
+
+        decoded << c
+
+        if (bit_len > 0) {
+            decoded << c*Num('1' + (bit_len-1).of { bits_fh.getc }.join, 2)
+        }
+    }
+
+    decoded.join
+}
+
+var str = join('', 'a'*13, 'b'*14, 'c'*10, 'd'*3, 'e'*1, 'f'*1, 'g'*4)
+
+var enc = VLR_encoding(str)
+var dec = VLR_decoding(enc)
+
+say enc
+say dec
+
+assert_eq(dec, str)
+
+with (File(__FILE__).read(':raw')) {|str|
+    var enc = VLR_encoding(str)
+    assert(enc.len < 8*str.len)
+    assert_eq(VLR_decoding(enc), str)
+}
+
+__END__
+011000011111010001100010111101010110001111110001011001001100011001010011001100011001111101
+aaaaaaaaaaaaabbbbbbbbbbbbbbccccccccccdddefgggg

Math/modular_binomial_fast.sf

@@ -81,6 +81,7 @@ func modular_binomial(n,k,m) {
     if (k > n)                   { return 0 }
     if (k.is_zero || (k == n))   { return 1%m }
     if (k.is_one  || (k == n-1)) { return n%m }
+    if (n-k < k)                 { k = (n - k) }
 
     var F = []
 

README.md

@@ -37,6 +37,7 @@ A nice collection of day-to-day Sidef scripts.
     * [Lzw file compression utf8](./Encoding/lzw_file_compression_utf8.sf)
     * [Run length encoding](./Encoding/run_length_encoding.sf)
     * [Substitution cipher](./Encoding/substitution_cipher.sf)
+    * [Variable length run encoding](./Encoding/variable_length_run_encoding.sf)
 * Encryption
     * [Age-lf](./Encryption/age-lf.sf)
     * [Backdoored rsa with x25519](./Encryption/backdoored_rsa_with_x25519.sf)