From Wikipedia, the free encyclopedia

This article may require cleanup to meet Wikipedia's quality standards. Please improve this article if you can. (December 2007)

The Burrows-Wheeler transform (BWT, also called block-sorting compression), is an algorithm used in data compression techniques such as bzip2. It was invented by Michael Burrows and David Wheeler in 1994 while working at Digital Systems Research Center in Palo Alto, California.^[1] It is based on a previously unpublished transformation discovered by Wheeler in 1983.

When a character string is transformed by the BWT, none of its characters change value. The transformation permutes the order of the characters. If the original string had several substrings that occurred often, then the transformed string will have several places where a single character is repeated multiple times in a row. This is useful for compression, since it tends to be easy to compress a string that has runs of repeated characters by techniques such as move-to-front transform and run-length encoding.

For example, the string:

SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES

could be transformed into this string, which is easier to compress because it has many repeated characters:

 TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT

The transform is done by sorting all rotations of the text, then taking the last column. For example, the text "^BANANA@" is transformed into "BNN^AA@A" through these steps (the red @ character indicates the 'EOF' pointer):

^BANANA@

^BANANA@
@^BANANA
A@^BANAN
NA@^BANA
ANA@^BAN
NANA@^BA
ANANA@^B
BANANA@^

ANANA@^B
ANA@^BAN
A@^BANAN
BANANA@^
NANA@^BA
NA@^BANA
^BANANA@
@^BANANA

BNN^AA@A

The following pseudocode gives a simple, but inefficient, way to calculate the BWT and its inverse. It assumes that the input string s contains a special character 'EOF' which is the last character, occurs nowhere else in the text, and is ignored during sorting.

 function BWT (string s)
   create a table, rows are all possible rotations of s
   sort rows alphabetically
   return (last column of a table)
 
 function inverseBWT (string s)
   create empty table 
       
   repeat length(s) times
       insert s as a column of table before first column of a table   // first insert creates first column
       sort rows of the table alphabetically
   // note: this creates rows of previous in reversed order -> previous first is last
   return (last row a table)

To understand why this creates more-easily-compressible data, let's consider transforming a long English text frequently containing the word "the". Sorting the rotations of this text will often group rotations starting with "he " together, and the last character of that rotation (which is also the character before the "he ") will usually be "t", so the result of the transform would contain a number of "t" characters along with the perhaps less-common exceptions (such as if it contains "Brahe ") mixed in. So it can be seen that the success of this transform depends upon one value having a high probability of occurring before a sequence, so that in general it needs fairly long samples (a few kilobytes at least) of appropriate data (such as text).

The remarkable thing about the BWT is not that it generates a more easily encoded output—an ordinary sort would do that—but that it is reversible, allowing the original document to be re-generated from the last column data.

The inverse can be understood this way. Take the final table in the BWT algorithm, and erase all but the last column. Given only this information, you can easily reconstruct the first column. The last column tells you all the characters in the text, so just sort these characters to get the first column. Then, the first and last columns together give you all pairs of successive characters in the document, where pairs are taken cyclically so that the last and first character form a pair. Sorting the list of pairs gives the first and second columns. Continuing in this manner, you can reconstruct the entire list. Then, the row with the "end of file" character at the end is the original text. Reversing the example above is done like this:

BNN^AA@A

B
N
N
^
A
A
@
A

A
A
A
B
N
N
^
@

BA
NA
NA
^B
AN
AN
@^
A@

AN
AN
A@
BA
NA
NA
^B
@^

BAN
NAN
NA@
^BA
ANA
ANA
@^B
A@^

ANA
ANA
A@^
BAN
NAN
NA@
^BA
@^B

BANA
NANA
NA@^
^BAN
ANAN
ANA@
@^BA
A@^B

ANAN
ANA@
A@^B
BANA
NANA
NA@^
^BAN
@^BA

BANAN
NANA@
NA@^B
^BANA
ANANA
ANA@^
@^BAN
A@^BA

ANANA
ANA@^
A@^BA
BANAN
NANA@
NA@^B
^BANA
@^BAN

BANANA
NANA@^
NA@^BA
^BANAN
ANANA@
ANA@^B
@^BANA
A@^BAN

ANANA@
ANA@^B
A@^BAN
BANANA
NANA@^
NA@^BA
^BANAN
@^BANA

BANANA@
NANA@^B
NA@^BAN
^BANANA
ANANA@^
ANA@^BA
@^BANAN
A@^BANA

ANANA@^
ANA@^BA
A@^BANA
BANANA@
NANA@^B
NA@^BAN
^BANANA
@^BANAN

BANANA@^
NANA@^BA
NA@^BANA
^BANANA@
ANANA@^B
ANA@^BAN
@^BANANA
A@^BANAN

ANANA@^B
ANA@^BAN
A@^BANAN
BANANA@^
NANA@^BA
NA@^BANA
^BANANA@
@^BANANA

^BANANA@

A number of optimizations can make these algorithms run more efficiently without changing the output. In BWT, there is no need to actually store the table. Each row of the table can be represented by a single pointer into the strings. In inverse BWT there is no need to store the table or to do the multiple sorts. It is sufficient to sort it once with a stable sort, and remember where each character moved. This gives a single-cycle permutation, whose cycle is the output. A "character" in the algorithm can be a byte, or a bit, or any other convenient size.

There is no need to have an actual 'EOF' character. Instead, a pointer can be used that remembers where in a string the 'EOF' would be if it existed. In this approach, the output of the BWT must include both the transformed string, and the final value of the pointer. That means the BWT does expand its input slightly. The inverse transform then shrinks it back down to the original size: it is given a string and a pointer, and returns just a string.

A complete description of the algorithms can be found in Burrows and Wheeler's paper, or in a number of online sources.

Note: Written in C (original found at: Polish Wikipedia article).

#include 
#include 
#include 
#include 
#include 
 
typedef unsigned char byte;
 
byte *rotlexcmp_buf = NULL;
int rottexcmp_bufsize = 0;
 
int rotlexcmp(const void *l, const void *r)
{
    int li = *(const int*)l, ri = *(const int*)r, ac=rottexcmp_bufsize;
    if(li == ri) return 0;
    while (rotlexcmp_buf[li] == rotlexcmp_buf[ri])
    {
        if (++li == rottexcmp_bufsize)
            li = 0;
        if (++ri == rottexcmp_bufsize)
            ri = 0;
        if (!--ac)
            return 0;
    }
    if (rotlexcmp_buf[li] > rotlexcmp_buf[ri])
        return 1;
    else
        return -1;
}
 
void bwt_encode(byte *buf_in, byte *buf_out, int size, int *primary_index)
{
    int indices[size];
    int i;
 
    for(i=0; i)
        indices[i] = i;
 
    rotlexcmp_buf = buf_in;
    rottexcmp_bufsize = size;
    qsort (indices, size, sizeof(int), rotlexcmp);
 
    for (i=0; i)
        buf_out[i] = buf_in[(indices[i]+size-1)%size];
 
    for (i=0; i)
    {
        if (indices[i] == 0) {
            *primary_index = i;
            return;
        }
    }
    assert (0);
}
 
void bwt_decode(byte *buf_in, byte *buf_out, int size, int primary_index)
{
    int buckets[256];
    int i,j,sum;
    int indices[size];
 
    memset( buckets, 0, sizeof( buckets ) );
 
    for (i=0; i)
        indices[i] = buckets[buf_in[i]]++;
 
    for (sum=i=0; i<256; i++)
    {
        register int __t = buckets[i];
        buckets[i] = sum;
        sum += __t;
    }
 
    for(j=primary_index,i=size; i--; j=indices[j] + buckets[buf_in[j]] )
        buf_out[i] = buf_in[j];
}
 
int main()
{
    byte buf1[] = "Polska Wikipedia";
    int size = strlen((const char*)buf1);
    byte buf2[size];
    byte buf3[size];
    int primary_index;
 
    bwt_encode (buf1, buf2, size, &primary_index);
    bwt_decode (buf2, buf3, size, primary_index);
 
    assert (!memcmp (buf1, buf3, size));
    printf ("Result is the same as input, that is: <%.*s>\n", size, buf3);
    // Print out encode/decode results:
    printf ("Input  : <%.*s>\n", size, buf1);
    printf ("Encoded: <%.*s>\n", size, buf2);
    printf ("Decoded: <%.*s>\n", size, buf3);
    return 0;
}

Note: Written in HTML Javascript (by Peter Mlich)

function compare_str(a,b)    //compare string
{return (a>b) ? 1 : ( (a) ? -1 : 0 );}
 
if (typeof(Array.prototype.sortstable) == 'undefined') {
 Array.prototype.sortstable = function (c) {
        if (c==null || typeof(c)!='function')
                c = function(a,b) {return ((a>b)? 1 : (a)? -1 : 0);}
        var mc = function(a,b)
                {
                var v = c(a[0],b[0]);
                return (v!=0)? v : ((a[1]>b[1])? 1 : (a[1][1])? -1 : 0);
                }
        var i;
        for (i=0,j=this.length;i) {this[i] = [this[i],i];}
        this.sort(mc);
        for (i=0,j=this.length;i) {this[i] = this[i][0];}
        return this;
}}
 
var comp_func = compare_str;
 
function func_code(obj_str1,obj_str2,obj_key)
{
var arr,i,j,l,str,key;
str = obj_str1.value;
arr = new Array();
l   = str.length;
for (i=0;i)        {arr[i] = new Array();}
for (i=0;i)        {arr[i][2]     = i;}                   //index row
for (i=l-1;i>=0;i--)    {arr[l-1-i][1] = str.substr(i,1);}        //last col
arr[0][0] = arr[l-1][1];
for (i=0;i-1;i++)     {arr[i+1][0]   = arr[i][1];}             //first col
arr.sortstable(function(a,b){return comp_func(a[0],b[0]);});
key = 0;
for (i=0;i)        {if (arr[i][2]==0) {key = i; break;}}
str = '';
for (i=0;i)        {str+= arr[i][1];}
obj_str2.value = str;
obj_key.value  = key;
}
 
function func_decode(obj_str1,obj_str2,obj_key)
{
var arr,i,j,l,str,key,arrx;
str = obj_str2.value;
key = obj_key.value;
arr    = new Array();
arr[0] = new Array();
arr[1] = new Array();
arr[2] = new Array();
l = str.length;
for (i=0;i)
        {
        arr[2][i] = i;                     //index row
        arr[1][i] = str.substr(i,1);   //last col
        arr[0][i] = arr[1][i];                //first col
        }
arr[0].sort(function(a,b){return comp_func(a,b);});
i   = key;
key = arr[1][i]; str = key; arr[2][i] = -1;
for (j=1;j)
        {
        for (i=0;i)
                {
                if (arr[2][i]!==-1 && arr[0][i]==key)
                        {key = arr[1][i]; str = key+str; arr[2][i] = -1; break;}
                }
        }
obj_str1.value = str;
}

1. ^ Burrows M and Wheeler D, A block sorting lossless data compression algorithm, Technical Report 124, Digital Equipment Corporation, 1994.

• ResearchIndex page for BWT paper at Penn State
• BWT paper hosted at HP
• Article by Mark Nelson on the BWT
• BWT Guide hosted at FrozenEther