Lucene.Net.Util.OpenBitSet.Clear C# (CSharp) Method

		public virtual void  Clear(int startIndex, int endIndex)
		{
			if (endIndex <= startIndex)
				return ;
			
			int startWord = (startIndex >> 6);
			if (startWord >= wlen)
				return ;
			
			// since endIndex is one past the end, this is index of the last
			// word to be changed.
			int endWord = ((endIndex - 1) >> 6);
			
			long startmask = - 1L << startIndex;
			long endmask = (long) (0xffffffffffffffffUL >> - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
			
			// invert masks since we are clearing
			startmask = ~ startmask;
			endmask = ~ endmask;
			
			if (startWord == endWord)
			{
				internalbits[startWord] &= (startmask | endmask);
				return ;
			}
			
			internalbits[startWord] &= startmask;
			
			int middle = System.Math.Min(wlen, endWord);
            for (int i = startWord + 1; i < middle; i++)
                internalbits[i] = 0L;
			if (endWord < wlen)
			{
				internalbits[endWord] &= endmask;
			}
		}
		

        public virtual void TestIntersection()
        {
            int numBits                  = TestUtil.NextInt32(Random, 100, 1 << 20);
            int numDocIdSets             = TestUtil.NextInt32(Random, 1, 4);
            IList <OpenBitSet> fixedSets = new List <OpenBitSet>(numDocIdSets);

            for (int i = 0; i < numDocIdSets; ++i)
            {
                fixedSets.Add(RandomOpenSet(numBits, Random.NextSingle()));
            }
            IList <WAH8DocIdSet> compressedSets = new List <WAH8DocIdSet>(numDocIdSets);

            foreach (OpenBitSet set in fixedSets)
            {
                compressedSets.Add(CopyOf(set, numBits));
            }

            WAH8DocIdSet union    = WAH8DocIdSet.Intersect(compressedSets);
            OpenBitSet   expected = new OpenBitSet(numBits);

            expected.Set(0, expected.Length);
            foreach (OpenBitSet set in fixedSets)
            {
                for (int previousDoc = -1, doc = set.NextSetBit(0); ; previousDoc = doc, doc = set.NextSetBit(doc + 1))
                {
                    if (doc == -1)
                    {
                        expected.Clear(previousDoc + 1, set.Length);
                        break;
                    }
                    else
                    {
                        expected.Clear(previousDoc + 1, doc);
                    }
                }
            }
            AssertEquals(numBits, expected, union);
        }