C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Mathematics/BitUnbiaser.cs

//-----------------------------------------------------------------------------
// BitUnbiaser.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Mathematics
{
    using System;
    using System.Text;

    public enum BitUnbiasAlgorithm
    {
        VonNeuman,

        MLS,

        AMLS,
    }

    public class BitUnbiaser
    {
        private BitUnbiasAlgorithm algorithm;

        public BitUnbiaser(BitUnbiasAlgorithm algorithm)
        {
            this.algorithm = algorithm;
        }

        public string Process(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                throw new ArgumentNullException("input", "input string cannot be null or empty");
            }

            if (input.Length < 2)
            {
                throw new ArgumentException("input must consist of at least 2 characters", "input"); 
            }

            StringBuilder output = new StringBuilder(input.Length);
            Amls(input, ref output);
            return output.ToString();
        }

        private void Amls(string input, ref StringBuilder output)
        {
            char[] inputC = input.ToCharArray();
            int start = 0;
            int end = input.Length - 1;
            AmlsStep(ref inputC, ref output, start, end);
        }

        private void AmlsStep(ref char[] inputC, ref StringBuilder output, int start, int end)
        {
            if (start >= end)
            {
                return;
            }

            int indexD = start;
            int indexL = start;
            int indexH = end;

            do
            {
                if (inputC[indexL] == inputC[indexH])
                {
                    inputC[indexD] = inputC[indexL];
                    indexD++;
                    inputC[indexH] = '0';
                }
                else
                {
                    output.Append(inputC[indexL]);
                    inputC[indexH] = '1';
                }

                indexH--;
                indexL++;
            } while (indexH > indexL);

            // Maybe terminate early 
            if (this.algorithm == BitUnbiasAlgorithm.VonNeuman)
            {
                return;
            }

            // Recurse for MLS
            indexD--;
            AmlsStep(ref inputC, ref output, start, indexD);

            // Maybe terminate early
            if (this.algorithm == BitUnbiasAlgorithm.MLS)
            {
                return;
            }

            // Recurse for AMLS
            indexH++;
            AmlsStep(ref inputC, ref output, indexH, end);
        }
    }
}

---