public Bloom(int elements, double falsePositiveRate)
        {
            var size = (int)(-elements * Math.Log(falsePositiveRate) / Math.Pow(Math.Log(2), 2)) / 8;
            HashFunctions = (int)(size * 8 / elements * Math.Log(2));

            Bits = new System.Collections.BitArray(size * 8);
        }

			public override DocIdSet GetDocIdSet(IndexReader reader)
			{
				System.Collections.BitArray bitset = new System.Collections.BitArray((5 % 64 == 0?5 / 64:5 / 64 + 1) * 64);
				bitset.Set(1, true);
				bitset.Set(3, true);
				return new DocIdBitSet(bitset);
			}

 public WD_HW_StatusDesc(string devName,byte[] status, byte[] diff)
 {
     ArrayhwStatus = new System.Collections.BitArray(status);
     this.diff = diff;
     this.devName = devName;
     m_status = status;
 }

			public override System.Collections.BitArray Bits(IndexReader reader)
			{
				System.Collections.BitArray bitset = new System.Collections.BitArray((5 % 64 == 0?5 / 64:5 / 64 + 1) * 64);
				bitset.Set(1, true);
				bitset.Set(3, true);
				return bitset;
			}

		public override System.Collections.BitArray Bits(IndexReader reader)
		{
			System.Collections.BitArray bits = new System.Collections.BitArray((reader.MaxDoc() % 64 == 0 ? reader.MaxDoc() / 64 : reader.MaxDoc() / 64 + 1) * 64);
			
			new IndexSearcher(reader).Search(query, new AnonymousClassHitCollector(bits, this));
			return bits;
		}

 /// <summary>Constructor</summary>
 public Result(bool best, BitArray bestHandBits, PokerHand bestHand, PokerHand selectedHand)
 {
     _best = best;
     _bestHandBits = bestHandBits;
     _bestHand = bestHand;
     _selectedHand = selectedHand;
 }

        public PartialFile(string path, int targetSize)
        {
            this.path = path;

            if (File.Exists(path)) {
                isCompleted = true;

                if (targetSize != -1 && new FileInfo(path).Length != targetSize) {
                    throw new ApplicationException("Attempting to initialize the size with an invalid size");
                }
                stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);

            } else if (File.Exists(PartialFileName)) {

                stream = File.Open(PartialFileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
                ReadBitmapInfo();

            } else {
                if (targetSize == -1) targetSize = DEFAULT_SIZE;
                var chunks = targetSize / CHUNK_SIZE;

                if (targetSize % CHUNK_SIZE > 0) chunks++;

                completedChunks = new System.Collections.BitArray(chunks, false);

                stream = File.Open(PartialFileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
                WriteBitmapInfo();
            }
        }

 public RGS_HW_StatusDesc(string devName,byte[] hw_status, byte[] diff)
 {
     ArrayhwStatus = new System.Collections.BitArray(hw_status);
     this.diff = diff;
     this.devName = devName;
     this.m_status = hw_status;
 }

        public override System.Collections.BitArray Bits(IndexReader reader)
        {
            if (cache == null)
            {
                cache = new System.Collections.Hashtable();
            }

            lock (cache.SyncRoot)
            {
                // check cache
                System.Collections.BitArray cached = (System.Collections.BitArray) cache[reader];
                if (cached != null)
                {
                    return cached;
                }
            }

            System.Collections.BitArray bits = new System.Collections.BitArray((reader.MaxDoc() % 64 == 0?reader.MaxDoc() / 64:reader.MaxDoc() / 64 + 1) * 64);

            new IndexSearcher(reader).Search(query, new AnonymousClassHitCollector(bits, this));

            lock (cache.SyncRoot)
            {
                // update cache
                cache[reader] = bits;
            }

            return bits;
        }

        public static IList<int> FindPrimes(int max)
        {
            //Initialize list to capacity using Legendre's constant to minimize copying lists as bounds are exceeded
              var vals = new List<int>((int)(max / (Math.Log(max) - 1.08366)));

              var maxSquareRoot = Math.Sqrt(max);

              //Use a BitArray for light-weight collection of numbers already elminated as not prime.
              var eliminated = new System.Collections.BitArray(max + 1);

              //2 is the only even prime, add it here and skip evaluating all even numbers below
              vals.Add(2);

              for (int i = 3; i <= max; i += 2)
              {
            if (!eliminated[i])
            {
              //We only need to evaluate up to sqrt (any non-primes beyond will already be eliminated as a multiple)
              if (i < maxSquareRoot)
              {
            //Eliminate all multiples i (after i squared, lower multiple are already eliminated)
            for (int j = i * i; j <= max; j += 2 * i)
              eliminated[j] = true;
              }

              //Add number to primes if it hasn't been eliminated
              vals.Add(i);
            }
              }
              return vals;
        }

        public static bool[,] Rasterize(Point[] points, int width, int height)
        {
            Contract.Requires(points != null);
            Contract.Requires(width > 0);
            Contract.Requires(height > 0);
            Contract.Requires(width % 8 == 0);
            Contract.Ensures(Contract.Result<bool[,]>() != null);
            Contract.Ensures(Contract.Result<bool[,]>().GetLength(0) == width);
            Contract.Ensures(Contract.Result<bool[,]>().GetLength(1) == height);

            var canvas = new Canvas { Background = Brushes.White, Width = width, Height = height };
            var polygon = new Polygon { Stroke = Brushes.Black, Fill = Brushes.Black, StrokeThickness = 1, Points = new PointCollection(points) };
            canvas.Children.Add(polygon);
            RenderOptions.SetEdgeMode(canvas, EdgeMode.Aliased);

            canvas.Measure(new Size(width, height));
            canvas.Arrange(new Rect(0, 0, canvas.DesiredSize.Width, canvas.DesiredSize.Height));

            var rtb = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
            rtb.Render(canvas);

            var fmb = new FormatConvertedBitmap(rtb, PixelFormats.BlackWhite, null, 0);
            var pixels = new byte[width * height / 8];
            fmb.CopyPixels(pixels, width / 8, 0);

            System.Collections.BitArray ba = new System.Collections.BitArray(pixels);

            var result = new bool[width, height];
            for (int i = 0, y = 0; y < height; ++y)
                for (int x = 0; x < width; ++x, ++i)
                    result[x, y] = !ba[i];

            return result;
        }

        protected override void BuildPatternBodyImpl(StringBuilder pattern, ICollection<string> requiredVariables, ICollection<string> arrayVariables, ICollection<string> mapVariables)
        {
            if (pattern == null)
                throw new ArgumentNullException("pattern");
            if (arrayVariables == null)
                throw new ArgumentNullException("arrayVariables");
            if (mapVariables == null)
                throw new ArgumentNullException("mapVariables");

            BitArray requiredPatterns = new BitArray(Variables.Count);
            List<string> variablePatterns = new List<string>();
            for (int i = 0; i < Variables.Count; i++)
            {
                VariableReference variable = Variables[i];
                if (requiredVariables.Contains(variable.Name))
                    requiredPatterns.Set(i, true);

                bool allowReservedSet = false;
                variablePatterns.Add(BuildVariablePattern(variable, allowReservedSet, null, requiredVariables, arrayVariables, mapVariables));
            }

            pattern.Append("(?:");
            AppendZeroOrMoreToEnd(pattern, requiredPatterns, variablePatterns, 0);
            pattern.Append(")");
        }

        static UriUtility()
        {
#if PORTABLE
            if (!Enum.TryParse("Compiled", out DefaultRegexOptions))
                DefaultRegexOptions = RegexOptions.None;
#else
            DefaultRegexOptions = RegexOptions.Compiled;
#endif

            _unreservedCharacters = new BitArray(256);
            for (char i = 'a'; i <= 'z'; i++)
                _unreservedCharacters.Set(i, true);
            for (char i = 'A'; i <= 'Z'; i++)
                _unreservedCharacters.Set(i, true);
            for (char i = '0'; i <= '9'; i++)
                _unreservedCharacters.Set(i, true);
            _unreservedCharacters.Set('-', true);
            _unreservedCharacters.Set('.', true);
            _unreservedCharacters.Set('_', true);
            _unreservedCharacters.Set('~', true);

            _generalDelimiters = new BitArray(256);
            _generalDelimiters.Set(':', true);
            _generalDelimiters.Set('/', true);
            _generalDelimiters.Set('?', true);
            _generalDelimiters.Set('#', true);
            _generalDelimiters.Set('[', true);
            _generalDelimiters.Set(']', true);
            _generalDelimiters.Set('@', true);

            _subDelimiters = new BitArray(256);
            _subDelimiters.Set('!', true);
            _subDelimiters.Set('$', true);
            _subDelimiters.Set('&', true);
            _subDelimiters.Set('(', true);
            _subDelimiters.Set(')', true);
            _subDelimiters.Set('*', true);
            _subDelimiters.Set('+', true);
            _subDelimiters.Set(',', true);
            _subDelimiters.Set(';', true);
            _subDelimiters.Set('=', true);
            _subDelimiters.Set('\'', true);

            _reservedCharacters = new BitArray(256).Or(_generalDelimiters).Or(_subDelimiters);

            _allowedHostCharacters = new BitArray(256).Or(_unreservedCharacters).Or(_subDelimiters);

            _allowedPathCharacters = new BitArray(256).Or(_unreservedCharacters).Or(_subDelimiters);
            _allowedPathCharacters.Set(':', true);
            _allowedPathCharacters.Set('@', true);

            _allowedQueryCharacters = new BitArray(256).Or(_allowedPathCharacters);
            _allowedQueryCharacters.Set('/', true);
            _allowedQueryCharacters.Set('?', true);

            _allowedFragmentCharacters = new BitArray(256).Or(_allowedPathCharacters);
            _allowedFragmentCharacters.Set('/', true);
            _allowedFragmentCharacters.Set('?', true);
        }

   public ThreadPlaySound(int recordid, int cnt, System.Collections.BitArray Status, TouchPanelManager touch_panel_mgr,Controller controller)
 {
     this.recordid = recordid;
     this.cnt = cnt;
     this.Status = Status;
     this.touch_panel_mgr = touch_panel_mgr;
     this.controller = controller;
 }

		public static BitArray ToOpenTK(this Keys buttons)
		{
			BitArray result = new BitArray((int)Key.LastKey + 1, false);
			int k;
			if (mapToOpenTK.TryGetValue((int)(buttons & ~Keys.Modifiers), out k))
				result[k] = true;
			return result;
		}

			public override System.Collections.BitArray Bits(IndexReader reader)
			{
				System.Collections.BitArray bitset = new System.Collections.BitArray((5 % 64 == 0 ? 5 / 64 : 5 / 64 + 1) * 64);
				for (int i = 0; i < 5; i++)
				{
					bitset.Set(i, true);
				} 
				return bitset;
			}

 public System.Collections.IEnumerable getEnum()
 {
     System.Collections.BitArray aryInx = new System.Collections.BitArray(diff);
     for (int i = 0; i < aryInx.Count; i++)
     {
         if (aryInx.Get(i))
             yield return (RGS_HW_Status_Bit_Enum)i;
     }
 }

 //取得所有錯誤訊息的位元咧舉值
 public System.Collections.IEnumerable getEnum(byte[] indexs)
 {
     //  throw new Exception("The method or operation is not implemented.");
     System.Collections.BitArray aryInx = new System.Collections.BitArray(indexs);
     for (int i = 0; i < aryInx.Count; i++)
     {
         if (aryInx.Get(i))
             yield return (RGS_HW_Status_Bit_Enum)i;
     }
 }

		public override System.Collections.BitArray Bits(IndexReader reader)
		{
			System.Collections.BitArray bits = new System.Collections.BitArray((reader.MaxDoc() % 64 == 0 ? reader.MaxDoc() / 64 : reader.MaxDoc() / 64 + 1) * 64);

			for (int increment = 0; doc >= bits.Length; increment =+ 64)
			{
				bits.Length += increment;
			}
			bits.Set(doc, true);
			
			return bits;
		}

 public void SrchDlg_Foo()
 {
     var arr = new System.Collections.BitArray(60);
     arr[14] = true;
     int i = 0;
     foreach (bool x in arr)
     {
         if (x)
         System.Diagnostics.Debug.Print("X: {0}", i);
         ++i;
     }
 }