CryptoRandom.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
 
namespace MyCaffe.basecode
{
    public class CryptoRandom : RandomNumberGenerator
    {
        private static readonly RNGCryptoServiceProvider m_rand = new RNGCryptoServiceProvider();
        private static Random m_rand1 = new Random();
        private IndexCollection m_rgIdx = null;
 
        METHOD m_method = METHOD.DEFAULT;
 
        public enum METHOD
        {
            SYSTEM,
            CRYPTO,
            UNIFORM_EXACT,
            DEFAULT = CRYPTO
        }
 
        public CryptoRandom(METHOD method = METHOD.DEFAULT, int nSeed = 0)
        {
            m_method = method;
 
            if (nSeed != 0)
            {
                if (m_method == METHOD.CRYPTO)
                    m_method = METHOD.SYSTEM;
 
                m_rand1 = new Random(nSeed);
            }
        }
 
#pragma warning disable 1591
 
        public override void GetBytes(byte[] data) 
        {
            m_rand.GetBytes(data);
        }
 
        public override void GetNonZeroBytes(byte[] data) 
        {
            m_rand.GetNonZeroBytes(data);
        }
 
#pragma warning restore 1591
 
        public double NextDouble()
        {
            if (m_method == METHOD.CRYPTO)
            {
                byte[] rgb = new byte[sizeof(UInt64)];
                m_rand.GetBytes(rgb);
                return (double)BitConverter.ToUInt64(rgb, 0) / (double)UInt64.MaxValue;
            }
 
            return m_rand1.NextDouble();
        }
 
        public double NextDouble(double dfMin, double dfMax)
        {
            return (NextDouble() * (dfMax - dfMin)) + dfMin;
        }
 
        public int Next(int nMinVal, int nMaxVal, bool bMaxInclusive = true)
        {
            int nVal = (int)Math.Round((NextDouble() * ((double)nMaxVal - nMinVal)) + nMinVal);
 
            if (!bMaxInclusive)
            {
                if (nVal == nMaxVal)
                    nVal--;
            }
 
            return nVal;
        }
 
        public int Next()
        {
            return Next(int.MaxValue);
        }
 
        public int Next(int nMaxVal)
        {
            if (m_method == METHOD.UNIFORM_EXACT)
            {
                if (m_rgIdx == null)
                    m_rgIdx = new IndexCollection(nMaxVal);
                else if (nMaxVal != m_rgIdx.Count)
                    throw new Exception("CryptoRandom: The maximum count has changed!");
 
                IndexCollection rgMin = m_rgIdx.GetMinumums();
                int nIdx = Next(0, rgMin.Count-1);
 
                nIdx = rgMin.Index(nIdx);
                return nIdx;
            }
 
            return Next(0, nMaxVal - 1);
        }
    }
 
    class IndexCollection 
    {
        Item[] m_rgItems;
 
        public IndexCollection(int nCount)
        {
            m_rgItems = new Item[nCount];
 
            for (int i = 0; i < nCount; i++)
            {
                m_rgItems[i] = new Item(i);
            }
        }
 
        public IndexCollection(Item[] rg)
        {
            m_rgItems = rg;
        }
 
        public int Count
        {
            get { return m_rgItems.Length; }
        }
 
        public int Add(int nIdx)
        {
            m_rgItems[nIdx].Count++;
            return m_rgItems[nIdx].Count;
        }
 
        public int Index(int nIdx)
        {
            m_rgItems[nIdx].Count++;
            return m_rgItems[nIdx].Index;
        }
 
        public IndexCollection GetMinumums()
        {
            int nMinCount = int.MaxValue;
 
            for (int i = 0; i < m_rgItems.Length; i++)
            {
                if (m_rgItems[i].Count < nMinCount)
                    nMinCount = m_rgItems[i].Count;
            }
 
            Item[] rgMin = m_rgItems.Where(p => p.Count == nMinCount).ToArray();
            return new IndexCollection(rgMin);
        }
    }
 
    class Item 
    {
        int m_nIdx;
        int m_nCount;
 
        public Item(int nIdx)
        {
            m_nIdx = nIdx;
            m_nCount = 0;
        }
 
        public int Index
        {
            get { return m_nIdx; }
        }
 
        public int Count
        {
            get { return m_nCount; }
            set { m_nCount = value; }
        }
 
        public override string ToString()
        {
            return m_nIdx.ToString() + " -> " + m_nCount.ToString();
        }
    }
}