GetContiguousArrayWithExceptions() public static method

Knocks out a few selected values from a contiguous array to allow meaningful difference testing.This would ordinarily be done by just using GetContiguousArray and flipping the bits off with Set() or Flip(), but those are not currently Implemented in RLE.
public static GetContiguousArrayWithExceptions ( int start, int end, int exceptions ) : int[]
start int
end int
exceptions int
return int[]
SetGenerator Class Documentation
Beispiel #1
0
        public virtual void DifferenceWithTest()
        {
            // Test arrayContainer-based sets
            int[]         set1     = { 1, 2, 3, 7 };
            RoaringBitset testSet1 = RoaringBitset.Create(set1);

            int[]         set2     = { 1, 4, 7 };
            RoaringBitset testSet2 = RoaringBitset.Create(set2);

            testSet1.DifferenceWith(testSet2);

            Assert.AreEqual(false, testSet1.Get(1));
            Assert.AreEqual(true, testSet1.Get(3));

            // Test bitsetContainer-based sets
            int[]         set3     = SetGenerator.GetContiguousArray(0, 5000);
            RoaringBitset testSet3 = RoaringBitset.Create(set3);

            int[]         setExceptions = { 4 };
            int[]         set4          = SetGenerator.GetContiguousArrayWithExceptions(0, 5000, setExceptions);
            RoaringBitset testSet4      = RoaringBitset.Create(set4);

            // Reduce contiguous array to single value (4) via DifferenceWith
            testSet3.DifferenceWith(testSet4);

            Assert.AreEqual(false, testSet3.Get(2));
            Assert.AreEqual(true, testSet3.Get(4));

            //
            // Reduce testSet2 to 4 as well
            testSet2.DifferenceWith(testSet4);
            Assert.AreEqual(false, testSet2.Get(1));
            Assert.AreEqual(true, testSet2.Get(4));

            // Remove contents of set1 from set4
            testSet4.DifferenceWith(testSet1);
            Assert.AreEqual(false, testSet4.Get(2));
            Assert.AreEqual(true, testSet4.Get(6));
        }
Beispiel #2
0
        public virtual void DifferenceTest()
        {
            int[]   set1     = { 1, 2, 3, 7 };
            IBitset testSet1 = CreateSetFromIndices(set1, 8);

            int[]   set2     = { 1, 4, 7 };
            IBitset testSet2 = CreateSetFromIndices(set2, 8);

            // These sparse sets will all use array containers.
            IBitset arrayContainerDiffSet = testSet1.Difference(testSet2);

            Assert.AreEqual(false, arrayContainerDiffSet.Get(1));
            Assert.AreEqual(true, arrayContainerDiffSet.Get(3));

            // Test difference from large contiguous bitset to exercise bitsetcontainers.
            int[]   set3     = SetGenerator.GetContiguousArray(0, 5000);
            IBitset testSet3 = CreateSetFromIndices(set3, 5000);

            int[]   setExceptions = { 4 };
            int[]   set4          = SetGenerator.GetContiguousArrayWithExceptions(0, 5000, setExceptions);
            IBitset testSet4      = CreateSetFromIndices(set4, 5000);

            // Both sets are using bitset containers
            IBitset bitsetContainerDiffSet = testSet3.Difference(testSet4);

            Assert.AreEqual(false, bitsetContainerDiffSet.Get(1));
            Assert.AreEqual(true, bitsetContainerDiffSet.Get(4));

            // Diff sets using bitset containers with array containers and vice versa
            IBitset mixedDiffSet1 = testSet4.Difference(testSet2);
            IBitset mixedDiffSet2 = testSet2.Difference(testSet4);

            Assert.AreEqual(false, mixedDiffSet1.Get(1));
            Assert.AreEqual(true, mixedDiffSet1.Get(3));

            Assert.AreEqual(false, mixedDiffSet2.Get(1));
            Assert.AreEqual(true, mixedDiffSet2.Get(4));
        }