C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Physics/SimpleEntropyCollector.cs

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

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

    using NewGamePhysics.Utilities;

    public class SimpleEntropyCollector
    {
        private int poolSize;

        private bool[] bitPool;

        private int bitsInPool;

        private int numValues;

        private double lastValue;

        private int numBits;

        private bool lastBit;

        private BitCount bitCount;

        public SimpleEntropyCollector()
        {
            // Initialize bitcount helper
            bitCount = new BitCount();

            // Initialize collector state
            this.Reset();
        }

        public int BitsInPool
        {
            get { return bitsInPool; }
        }

        public void Reset()
        {
            // Reset pool and value trackers
            this.poolSize = 1024;
            this.bitsInPool = 0;
            this.bitPool = new bool[poolSize];
            this.numValues = 0;
            this.numBits = 0;
        }

        public void AddValue(double value)
        {
            if (numValues == 1)
            {
                // Different between values
                double delta = this.lastValue - value;

                // Translate the double into a 64 bit long.
                long deltaBits = BitConverter.DoubleToInt64Bits(delta);

                // Get bitcount
                int totalBits = this.bitCount.FastBitcount(deltaBits);

                // Generate this bit
                bool newBit = (bool)((totalBits & 1) == 1);

                // von Neumann corrector to unbias bitstream
                if (numBits == 1)
                {
                    // Check for 10: add a 1
                    if ((!newBit) && (this.lastBit))
                    {
                        // Use LSB of bitcount
                        if (this.bitsInPool < 1024)
                        {
                            this.bitPool[this.bitsInPool] = true;
                            this.bitsInPool++;
                        }
                    }
                    // Check for 01: add a 0
                    else if ((newBit) && (!this.lastBit))
                    {
                        // Use LSB of bitcount
                        if (this.bitsInPool < 1024)
                        {
                            this.bitPool[this.bitsInPool] = false;
                            this.bitsInPool++;
                        }
                    }
                    else
                    {
                        // Discard 00 and 11 patterns
                    }
                    // Reset corrector counter
                    this.numBits = 0;
                }
                else
                {
                    // Store bit
                    this.lastBit = newBit;
                    this.numBits++;
                }

                // Reset value count to we cache the next submission
                this.numValues = 0;
            }
            else
            {
                // Just cache value for next call
                this.lastValue = value;

                // Set value count so we process the next submission
                this.numValues = 1;
            }
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            if (this.bitsInPool > 0)
            {
                for (int i = bitsInPool - 1; i >= 0; i--)
                {
                    if (bitPool[i])
                    {
                        sb.Append("1");
                    }
                    else
                    {
                        sb.Append("0");
                    }
                }
            }

            return sb.ToString();
        }

    }
}

---