B<Compression::Util> is a function-based module, implementing various techniques used in data compression, such as:
* Burrows-Wheeler transform
* Move-to-front transform
* Huffman Coding
* Arithmetic Coding (in fixed bits)
* Run-length encoding
* Fibonacci coding
* Elias gamma/omega coding
* Delta coding
* Bzip2-like compression
* LZ77/LZSS compression
* LZW compression
The provided techniques can be easily combined in various ways to create powerful compressors, such as the Bzip2 compressor, which is a pipeline of the following methods:
1. Run-length encoding (RLE4)
2. Burrows-Wheeler transform (BWT)
3. Move-to-front transform (MTF)
4. Zero run-length encoding (ZRLE)
5. Huffman coding
This functionality is provided by the function C<bz2_compress()>, which can be explicitly implemented as:
use 5.036;
use List::Util qw(uniq);
use Compression::Util qw(:all);
my $data = do { open my $fh, '<:raw', $^X; local $/; <$fh> };
my $rle4 = rle4_encode([unpack('C*', $data)]);
my ($bwt, $idx) = bwt_encode(pack('C*', @$rle4));
my ($mtf, $alphabet) = mtf_encode([unpack("C*", $bwt)]);
my $rle = zrle_encode($mtf);
open my $out_fh, '>:raw', \my $enc;
print $out_fh pack('N', $idx);
print $out_fh encode_alphabet($alphabet);
create_huffman_entry($rle, $out_fh);
say "Original size : ", length($data);
say "Compressed size: ", length($enc);
# Decompress the result
bz2_decompress($enc) eq $data or die "decompression error";
=head2 TERMINOLOGY
=head3 bit
A bit value is either C<1> or C<0>.
=head3 bitstring
A bitstring is a string containing only 1s and 0s.
=head3 byte
A byte value is an integer between C<0> and C<255>, inclusive.
=head3 string
A string means a binary (non-UTF*) string.
=head3 symbols
An array of symbols means an array of non-negative integer values.
=head3 filehandle
An input filehandle is denoted by C<$fh>, while an output file-handle is denoted by C<$out_fh>.
The encoding of input and output file-handles must be set to C<:raw>.
=head1 HIGH-LEVEL FUNCTIONS
create_huffman_entry(\@symbols) # Create a Huffman Coding block
decode_huffman_entry($fh) # Decode a Huffman Coding block
create_ac_entry(\@symbols) # Create an Arithmetic Coding block
decode_ac_entry($fh) # Decode an Arithmetic Coding block
create_adaptive_ac_entry(\@symbols) # Create an Adaptive Arithmetic Coding block
decode_adaptive_ac_entry($fh) # Decode an Adaptive Arithmetic Coding block
huffman_decode($bitstring, \%dict) # Huffman decoding, given a string of bits
huffman_from_freq(\%freq) # Create Huffman dictionaries, given an hash of frequencies
huffman_from_symbols(\@symbols) # Create Huffman dictionaries, given an array of symbols
huffman_from_code_lengths(\@lens) # Create canonical Huffman codes, given an array of code lengths
make_deflate_tables($size) # Returns the DEFLATE tables for distance and length symbols
find_deflate_index($value, \@table) # Returns the index in a DEFLATE table, given a numerical value
lz77_encode($string) # LZ77 compression of a string into literals, indices and lengths
lzss_encode($string) # LZSS compression of a string into literals, indices and lengths
lz77_decode(\@lits, \@idxs, \@lens) # Inverse of the above two methods
deflate_encode(\@lits, \@idxs, \@lens) # DEFLATE-like encoding of values returned by lzss_encode()
deflate_decode($fh) # Inverse of the above method
=head1 INTERFACE FOR HIGH-LEVEL FUNCTIONS
=head2 create_huffman_entry
create_huffman_entry(\@symbols, $out_fh); # writes to $out_fh
my $string = create_huffman_entry(\@symbols); # returns a binary string
High-level function that generates a Huffman coding block.
It takes two parameters: C<\@symbols>, which represents the symbols to be encoded, and C<$out_fh>, which is optional, and represents the file-handle where to write the result.
When the second parameter is omitted, the function returns a binary string.
=head2 decode_huffman_entry
my $symbols = decode_huffman_entry($fh);
my $symbols = decode_huffman_entry($string);
Inverse of C<create_huffman_entry()>.
=head2 create_ac_entry
create_ac_entry(\@symbols, $out_fh); # writes to $out_fh
my $string = create_ac_entry(\@symbols); # returns a binary string
High-level function that generates an Arithmetic Coding block.
It takes two parameters: C<\@symbols>, which represents the symbols to be encoded, and C<$out_fh>, which is optional, and represents the file-handle where to write the result.
When the second parameter is omitted, the function returns a binary string.
=head2 decode_ac_entry
my $symbols = decode_ac_entry($fh);
my $symbols = decode_ac_entry($string);
Inverse of C<create_ac_entry()>.
=head2 create_adaptive_ac_entry
create_adaptive_ac_entry(\@symbols, $out_fh); # writes to $out_fh
my $string = create_adaptive_ac_entry(\@symbols); # returns a binary string
High-level function that generates an Adaptive Arithmetic Coding block.
It takes two parameters: C<\@symbols>, which represents the symbols to be encoded, and C<$out_fh>, which is optional, and represents the file-handle where to write the result.
When the second parameter is omitted, the function returns a binary string.
=head2 decode_adaptive_ac_entry
my $symbols = decode_adaptive_ac_entry($fh);
my $symbols = decode_adaptive_ac_entry($string);
Inverse of C<create_adaptive_ac_entry()>.
=head2 lz77_compress
# With Huffman coding
lz77_compress($data, $out_fh); # writes to file-handle
my $string = lz77_compress($data); # returns a binary string
# With Arithmetic Coding
lz77_compress($data, $out_fh, \&create_ac_entry); # writes to file-handle
my $string = lz77_compress($data, undef, \&create_ac_entry); # returns a binary string
High-level function that performs LZ77 (Lempel-Ziv 1977) compression on the provided data, using the pipeline:
1. lz77_encode
2. deflate_encode
=head2 lzss_compress
# With Huffman coding
lzss_compress($data, $out_fh); # writes to file-handle
my $string = lzss_compress($data); # returns a binary string
# With Arithmetic Coding
lzss_compress($data, $out_fh, \&create_ac_entry); # writes to file-handle
my $string = lzss_compress($data, undef, \&create_ac_entry); # returns a binary string
High-level function that performs LZSS (Lempel-Ziv-Storer-Szymanski) compression on the provided data, using the pipeline:
1. lzss_encode
2. deflate_encode
It takes a single parameter, C<$data>, representing the data string to be compressed.
=head2 lz77_decompress / lzss_decompress
# Writing to file-handle
lzss_decompress($fh, $out_fh);
lzss_decompress($string, $out_fh);
# Writing to file-handle (does Arithmetic decoding)
my $data = bz2_decompress($fh, undef, \&decode_ac_entry);
my $data = bz2_decompress($string, undef, \&decode_ac_entry);
Inverse of C<bz2_compress()>.
=head2 bz2_compress_symbolic
# Does Huffman coding
bz2_compress_symbolic(\@symbols, $out_fh); # writes to file-handle
my $string = bz2_compress_symbolic(\@symbols); # returns a binary string
# Does Arithmetic coding
bz2_compress_symbolic(\@symbols, $out_fh, \&create_ac_entry); # writes to file-handle
my $string = bz2_compress_symbolic(\@symbols, undef, \&create_ac_entry); # returns a binary string
Similar to C<bz2_compress()>, except that it accepts an arbitrary array-ref of non-negative integer symbols as input. It is also a bit slower on large inputs.
=head2 bz2_decompress_symbolic
# Using Huffman coding
my $symbols = bz2_decompress_symbolic($fh);
my $symbols = bz2_decompress_symbolic($string);
# Using Arithmetic coding
my $symbols = bz2_decompress_symbolic($fh, \&decode_ac_entry);
my $symbols = bz2_decompress_symbolic($string, \&decode_ac_entry);
Inverse of C<bz2_compress_symbolic()>.
=head1 INTERFACE FOR MEDIUM-LEVEL FUNCTIONS
=head2 frequencies
my $freq = frequencies(\@symbols);
Returns an hash ref dictionary with frequencies, given an array of symbols.
=head2 deltas
my $deltas = deltas(\@integers);
Computes the differences between consecutive integers, returning an array.
=head2 accumulate
my $integers = accumulate(\@deltas);
Inverse of C<deltas()>.
=head2 delta_encode
my $string = delta_encode(\@integers);
Encodes a sequence of integers (including negative integers) using Delta + Run-length + Elias omega coding, returning a binary string.
Delta encoding calculates the difference between consecutive integers in the sequence and encodes these differences using Elias omega coding. When it's beneficial, runs of identitical symbols are collapsed with RLE.
It takes two parameters: C<\@integers>, representing the sequence of arbitrary integers to be encoded, and an optional parameter which defaults to C<0>. If the second parameter is set to a true value, double Elias omega coding is performed, which results in better compression for very large integers.
=head2 delta_decode
# Given a file-handle
my $integers = delta_decode($fh);
# Given a string
my $integers = delta_decode($string);
Inverse of C<delta_encode()>.
=head2 fibonacci_encode
my $string = fibonacci_encode(\@symbols);
Encodes a sequence of non-negative integers using Fibonacci coding, returning a binary string.
=head2 fibonacci_decode
# Given a file-handle
my $symbols = fibonacci_decode($fh);
# Given a binary string
my $symbols = fibonacci_decode($string);
Inverse of C<fibonacci_encode()>.
=head2 elias_gamma_encode
my $string = elias_gamma_encode(\@symbols);
Encodes a sequence of non-negative integers using Elias Gamma coding, returning a binary string.
=head2 elias_gamma_decode
# Given a file-handle
my $symbols = elias_gamma_decode($fh);
# Given a binary string
my $symbols = elias_gamma_decode($string);
Inverse of C<elias_gamma_encode()>.
=head2 elias_omega_encode
my $string = elias_omega_encode(\@symbols);
Encodes a sequence of non-negative integers using Elias Omega coding, returning a binary string.
=head2 elias_omega_decode
# Given a file-handle
my $symbols = elias_omega_decode($fh);
# Given a binary string
my $symbols = elias_omega_decode($string);
Inverse of C<elias_omega_encode()>.
=head2 abc_encode
my $string = abc_encode(\@symbols);
Encodes a sequence of non-negative integers using the Adaptive Binary Concatenation encoding method.
This method is particularly effective in encoding a sequence of integers that are in ascending order.
=head2 abc_decode
# Given a filehandle
my $symbols = abc_decode($fh);
# Given a binary string
my $symbols = abc_decode($string);
Inverse of C<abc_encode()>.
=head2 obh_encode
# With Huffman Coding
my $string = obh_encode(\@symbols);
# With Arithemtic Coding
my $string = obh_encode(\@symbols, \&create_ac_entry);
Encodes a sequence of non-negative integers using offset bits and Huffman coding.
This method is particularly effective in encoding a sequence of moderately large random integers, such as the list of indices returned by C<lz77_encode()>.
=head2 obh_decode
# Given a filehandle
my $symbols = obh_decode($fh); # Huffman decoding
my $symbols = obh_decode($fh, \&decode_ac_entry); # Arithemtic decoding
# Given a binary string
my $symbols = obh_decode($string); # Huffman decoding
my $symbols = obh_decode($string, \&decode_ac_entry); # Arithemtic decoding
Inverse of C<obh_encode()>.
=head2 bwt_encode
my ($bwt, $idx) = bwt_encode($string);
my ($bwt, $idx) = bwt_encode($string, $lookahead_len);
Applies the Burrows-Wheeler Transform (BWT) to a given string.
It returns two values: C<$bwt>, which represents the transformed string, and C<$idx>, which holds the index of the original string in the sorted list of rotations.
It takes an optional argument C<$lookahead_len>, which defaults to C<128>, representing the length of look-ahead during sorting.
=head2 bwt_decode
my $string = bwt_decode($bwt, $idx);
Reverses the Burrows-Wheeler Transform (BWT) applied to a string.
It takes two parameters: C<$bwt>, which is the transformed string, and C<$idx>, which represents the index of the original string in the sorted list of rotations.
The function returns the original string.
=head2 bwt_encode_symbolic
my ($bwt_symbols, $idx) = bwt_encode_symbolic(\@symbols);
Applies the Burrows-Wheeler Transform (BWT) to a sequence of symbolic elements.
It takes a single parameter C<\@symbols>, which represents the sequence of numerical symbols to be transformed.
The function returns two elements: C<$bwt_symbols>, which represents the transformed symbolic sequence, and C<$idx>, the index of the original sequence in the sorted list of rotations.
=head2 bwt_decode_symbolic
my $symbols = bwt_decode_symbolic(\@bwt_symbols, $idx);
Reverses the Burrows-Wheeler Transform (BWT) applied to a sequence of symbolic elements.
It takes two parameters: C<\@bwt_symbols>, which represents the transformed symbolic sequence, and C<$idx>, the index of the original sequence in the sorted list of rotations.
The function returns the original sequence of symbolic elements.
=head2 mtf_encode
my $mtf = mtf_encode(\@symbols, \@alphabet);
my ($mtf, $alphabet) = mtf_encode(\@symbols);
Performs Move-To-Front (MTF) encoding on a sequence of symbols.
It takes one parameter: C<\@symbols>, representing the sequence of symbols to be encoded.
The function returns the encoded MTF sequence and the sorted list of unique symbols in the input data, representing the alphabet.
Optionally, the alphabet can be provided as a second argument. When two arguments are provided, only the MTF sequence is returned.
=head2 mtf_decode
my $symbols = mtf_decode(\@mtf, \@alphabet);
Inverse of C<mtf_encode()>.
=head2 encode_alphabet
my $string = encode_alphabet(\@alphabet);
Efficienlty encodes an alphabet of symbols into a binary string.
=head2 decode_alphabet
my $alphabet = decode_alphabet($fh);
my $alphabet = decode_alphabet($string);
Decodes an encoded alphabet, given a file-handle or a binary string, returning an array of symbols. Inverse of C<encode_alphabet()>.
=head2 run_length
my $rl = run_length(\@symbols);
my $rl = run_length(\@symbols, $max_run);
Performs Run-Length Encoding (RLE) on a sequence of symbolic elements.
It takes two parameters: C<\@symbols>, representing an array of symbols, and C<$max_run>, indicating the maximum run length allowed.
The function returns a 2D-array, with pairs: C<[symbol, run_length]>, such that the following code reconstructs the C<\@symbols> array:
my @symbols = map { ($_->[0]) x $_->[1] } @$rl;
By default, the maximum run-length is unlimited.
=head2 rle4_encode
my $rle4 = rle4_encode(\@symbols);
my $rle4 = rle4_encode(\@symbols, $max_run);
Performs Run-Length Encoding (RLE) on a sequence of symbolic elements, specifically designed for runs of four or more consecutive symbols.
It takes two parameters: C<\@symbols>, representing an array of symbols, and C<$max_run>, indicating the maximum run length allowed during encoding.
The function returns the encoded RLE sequence as an array-ref of symbols.
By default, the maximum run-length is limited to C<255>.
=head2 rle4_decode
my $symbols = rle4_decode($rle4);
Inverse of C<rle4_encode()>.
=head2 zrle_encode
my $zrle = zrle_encode(\@symbols);
Performs Zero-Run-Length Encoding (ZRLE) on a sequence of symbolic elements.
It takes a single parameter C<\@symbols>, representing the sequence of symbols to be encoded, and returns the encoded ZRLE sequence as an array-ref of symbols.
This function efficiently encodes only runs of zeros, but also increments each symbol by C<1>.
=head2 zrle_decode
my $symbols = zrle_decode($zrle);
Inverse of C<zrle_encode()>.
=head2 ac_encode
my ($bitstring, $freq) = ac_encode(\@symbols);
Performs Arithmetic Coding on the provided symbols.
It takes a single parameter, C<\@symbols>, representing the symbols to be encoded.
The function returns two values: C<$bitstring>, which is a string of 1s and 0s, and C<$freq>, representing the frequency table used for encoding.
=head2 ac_decode
my $symbols = ac_decode($bits_fh, \%freq);
my $symbols = ac_decode($bitstring, \%freq);
Performs Arithmetic Coding decoding using the provided frequency table and a string of 1s and 0s. Inverse of C<ac_encode()>.
It takes two parameters: C<$bitstring>, representing a string of 1s and 0s containing the arithmetic coded data, and C<\%freq>, representing the frequency table used for encoding.
The function returns the decoded sequence of symbols.
=head2 adaptive_ac_encode
my ($bitstring, $alphabet) = adaptive_ac_encode(\@symbols);
Performs Adaptive Arithmetic Coding on the provided symbols.
It takes a single parameter, C<\@symbols>, representing the symbols to be encoded.
The function returns two values: C<$bitstring>, which is a string of 1s and 0s, and C<$alphabet>, which is an array-ref of distinct sorted symbols.
=head2 adaptive_ac_decode
my $symbols = adaptive_ac_decode($bits_fh, \@alphabet);
my $symbols = adaptive_ac_decode($bitstring, \@alphabet);
Performs Adaptive Arithmetic Coding decoding using the provided frequency table and a string of 1s and 0s.
It takes two parameters: C<$bitstring>, representing a string of 1s and 0s containing the adaptive arithmetic coded data, and C<\@alphabet>, representing the array of distinct sorted symbols that appear in the encoded data.
The function returns the decoded sequence of symbols.
=head2 lzw_encode
my $symbols = lzw_encode($string);
Performs Lempel-Ziv-Welch (LZW) encoding on the provided string.
It takes a single parameter, C<$string>, representing the data to be compressed. The function returns the encoded symbols.
=head2 lzw_decode
my $string = lzw_decode(\@symbols);
Performs Lempel-Ziv-Welch (LZW) decoding on the provided symbols. Inverse of C<lzw_encode()>.
It takes a single parameter, C<\@symbols>, representing the encoded symbols to be decompressed. The function returns the decoded string.
=head1 INTERFACE FOR LOW-LEVEL FUNCTIONS
=head2 read_bit
my $bit = read_bit($fh, \$buffer);
Reads a single bit from a file-handle C<$fh>.
The function stores the extra bits inside the C<$buffer>, reading one character at a time from the filehandle.
=head2 read_bits
my $bitstring = read_bits($fh, $bits_len);
Reads a specified number of bits (C<$bits_len>) from a file-handle (C<$fh>) and returns them as a string.
=head2 binary_vrl_encode
my $bitstring_enc = binary_vrl_encode($bitstring);
Given a string of 1s and 0s, returns back a bitstring of 1s and 0s encoded using variable run-length encoding.
=head2 binary_vrl_decode
my $bitstring = binary_vrl_decode($bitstring_enc);
Given an encoded bitstring, returned by C<binary_vrl_encode()>, gives back the decoded string of 1s and 0s.
=head2 bwt_sort
my $indices = bwt_sort($string);
my $indices = bwt_sort($string, $lookahead_len);
Low-level function that sorts the rotations of a given string using the Burrows-Wheeler Transform (BWT) algorithm.
It takes two parameters: C<$string>, which is the input string to be transformed, and C<$LOOKAHEAD_LEN> (optional), representing the length of look-ahead during sorting.
The function returns an array-ref of indices.
There is probably no need to call this function explicitly. Use C<bwt_encode()> instead!
=head2 bwt_sort_symbolic
my $indices = bwt_sort_symbolic(\@symbols);
Low-level function that sorts the rotations of a sequence of symbolic elements using the Burrows-Wheeler Transform (BWT) algorithm.
It takes a single parameter C<\@symbols>, which represents the input sequence of symbolic elements. The function returns an array of indices.
There is probably no need to call this function explicitly. Use C<bwt_encode_symbolic()> instead!
=head2 huffman_from_freq
my ($dict, $rev_dict) = huffman_from_freq(\%freq);
Low-level function that constructs Huffman prefix codes, based on the frequency of symbols provided in a hash table.
It takes a single parameter, C<\%freq>, representing the hash table where keys are symbols, and values are their corresponding frequencies.
The function returns two values: C<$dict>, which represents the constructed Huffman dictionary, and C<$rev_dict>, which holds the reverse mapping of Huffman codes to symbols.
=head2 huffman_from_symbols
my ($dict, $rev_dict) = huffman_from_symbols(\@symbols);
Low-level function that constructs Huffman prefix codes, given an array of symbols.
It takes a single parameter, C<\@symbols>. Interanlly, it computes the frequency of each symbols and generates the Huffman prefix codes.
The function returns two values: C<$dict>, which represents the constructed Huffman dictionary, and C<$rev_dict>, which holds the reverse mapping of Huffman codes to symbols.
=head2 huffman_from_code_lengths
my ($dict, $rev_dict) = huffman_from_code_lengths(\@code_lengths);
Low-level function that constructs a dictionary of canonical prefix codes, given an array of code lengths, as defined in RFC 1951 (Section 3.2.2).
It takes a single parameter, C<\@code_lengths>, where entry C<$i> in the array corresponds to the code length for symbol C<$i>.
The function returns two values: C<$dict>, which represents the constructed Huffman dictionary, and C<$rev_dict>, which holds the reverse mapping of Huffman codes to symbols.
=head2 huffman_encode
my $bits = huffman_encode(\@symbols, $dict);
Low-level function that performs Huffman encoding on a sequence of symbols using a provided dictionary, returned by C<huffman_from_freq()>.
It takes two parameters: C<\@symbols>, representing the sequence of symbols to be encoded, and C<$dict>, representing the Huffman dictionary mapping symbols to their corresponding Huffman codes.
The function returns a concatenated string of 1s and 0s, representing the Huffman-encoded sequence of symbols.
=head2 huffman_decode
my $symbols = huffman_decode($bits, $rev_dict);
Low-level function that decodes a Huffman-encoded binary string into a sequence of symbols using a provided reverse dictionary.
It takes two parameters: C<$bits>, representing the Huffman-encoded string of 1s and 0s, as returned by C<huffman_encode()>, and C<$rev_dict>, representing the reverse dictionary mapping Huffman codes to their corresponding symbols.
The function returns the decoded sequence of symbols as an array-ref.
=head2 lzss_encode
my ($literals, $indices, $lengths) = lzss_encode($data);
Low-level function that performs LZSS (Lempel-Ziv-Storer-Szymanski) compression on the provided data.
It takes a single parameter, C<$data>, representing the data string to be compressed.
The function returns three values: C<$literals>, which is an array-ref of uncompressed bytes, C<$indices>, which contains the indices of the back-references, and C<$lengths>, which holds the lengths of the matched sub-strings.
A back-reference is returned only when it's beneficial (i.e.: when it may not inflate the data). Otherwise, the corresponding index and length are both set to C<0>.
The output can be decompressed with C<lz77_decode()>.
=head2 lz77_encode
my ($literals, $indices, $lengths) = lz77_encode($data);
Low-level function that performs LZ77 (Lempel-Ziv 1977) compression on the provided data.
It takes a single parameter, C<$data>, representing the data string to be compressed.
The function returns three values: C<$literals>, which is an array-ref of uncompressed bytes, C<$indices>, which contains the indices of the matched sub-strings, and C<$lengths>, which holds the lengths of the matched sub-strings.
Lengths are limited to C<255>.
=head2 lz77_decode / lzss_decode
my $data = lz77_decode($literals, $indices, $lengths);
my $data = lzss_decode($literals, $indices, $lengths);
Low-level function that performs LZ77 (Lempel-Ziv 1977) decompression using the provided literals, indices, and lengths of matched sub-strings.
It takes three parameters: C<$literals>, representing the array-ref of uncompressed bytes, C<$indices>, containing the indices of the matched sub-strings, and C<$lengths>, holding the lengths of the matched sub-strings.
The function returns the decompressed data as a string.
=head2 deflate_encode
# Returns a binary string
my $string = deflate_encode(\@literals, \@distances, \@lengths);
my $string = deflate_encode(\@literals, \@distances, \@lengths, \&create_ac_entry);
Low-level function that encodes the results returned by C<lz77_encode()> and C<lzss_encode()>, using a DEFLATE-like approach, combined with Huffman coding.
An optional argument can be provided as C<\&create_ac_entry> to use Arithmetic Coding instead of Huffman coding. The default value is C<\&create_huffman_entry>.
=head2 deflate_decode
# Huffman decoding
my ($literals, $indices, $lengths) = deflate_decode($fh);
my ($literals, $indices, $lengths) = deflate_decode($string);
# Arithmetic decoding
my ($literals, $indices, $lengths) = deflate_decode($fh, \&decode_ac_entry);
my ($literals, $indices, $lengths) = deflate_decode($string, \&decode_ac_entry);
Inverse of C<deflate_encode()>.
=head2 make_deflate_tables
my ($DISTANCE_SYMBOLS, $LENGTH_SYMBOLS, $LENGTH_INDICES) = make_deflate_tables($size);
Low-level function that returns a list of tables used in encoding the indices and lengths returned by C<lz77_encode()> and C<lzss_encode()>.
There is no need to call this function explicitly. Use C<deflate_encode()> instead!
=head2 find_deflate_index
my $index = find_deflate_index($value, $DISTANCE_SYMBOLS);
Low-level function that returns the index inside the DEFLATE tables for a given value.
=head1 EXPORT
Each function can be exported individually, as:
use Compression::Util qw(bz2_compress);
By specifying the B<:all> keyword, will export all the exportable functions:
use Compression::Util qw(:all);
Nothing is exported by default.
=head1 SEE ALSO
=over 4
=item * Data Compression (Summer 2023) - Lecture 4 - The Unix 'compress' Program: