public virtual void TestEquals() { // this test can't handle numBits==0: int numBits = Random.Next(2000) + 1; Int64BitSet b1 = new Int64BitSet(numBits); Int64BitSet b2 = new Int64BitSet(numBits); Assert.IsTrue(b1.Equals(b2)); Assert.IsTrue(b2.Equals(b1)); for (int iter = 0; iter < 10 * RandomMultiplier; iter++) { int idx = Random.Next(numBits); if (!b1.Get(idx)) { b1.Set(idx); Assert.IsFalse(b1.Equals(b2)); Assert.IsFalse(b2.Equals(b1)); b2.Set(idx); Assert.IsTrue(b1.Equals(b2)); Assert.IsTrue(b2.Equals(b1)); } } // try different type of object Assert.IsFalse(b1.Equals(new object())); }
public virtual void TestEnsureCapacity() { Int64BitSet bits = new Int64BitSet(5); bits.Set(1); bits.Set(4); Int64BitSet newBits = Int64BitSet.EnsureCapacity(bits, 8); // grow within the word Assert.IsTrue(newBits.Get(1)); Assert.IsTrue(newBits.Get(4)); newBits.Clear(1); // we align to 64-bits, so even though it shouldn't have, it re-allocated a long[1] Assert.IsTrue(bits.Get(1)); Assert.IsFalse(newBits.Get(1)); newBits.Set(1); newBits = Int64BitSet.EnsureCapacity(newBits, newBits.Length - 2); // reuse Assert.IsTrue(newBits.Get(1)); bits.Set(1); newBits = Int64BitSet.EnsureCapacity(bits, 72); // grow beyond one word Assert.IsTrue(newBits.Get(1)); Assert.IsTrue(newBits.Get(4)); newBits.Clear(1); // we grew the long[], so it's not shared Assert.IsTrue(bits.Get(1)); Assert.IsFalse(newBits.Get(1)); }
private void CheckNextSetBitArray(int[] a, int numBits) { Int64BitSet obs = MakeLongFixedBitSet(a, numBits); BitSet bs = MakeBitSet(a); DoNextSetBit(bs, obs); }
public void TestClearLarge() { Random random = Random; int iters = AtLeast(1000); for (int it = 0; it < iters; it++) { int sz = AtLeast(1200); Int64BitSet a = new Int64BitSet(sz); Int64BitSet b = new Int64BitSet(sz); int from = random.Next(sz - 1); int to = random.Next(from, sz); for (int i = 0; i < sz / 2; i++) { int index = random.Next(sz - 1); a.Set(index); if (index < from || index >= to) { b.Set(index); } } a.Clear(from, to); Assert.True(a.Equals(b)); } }
public void TestClearSmall() { Int64BitSet a = new Int64BitSet(30); // 0110010111001000101101001001110...0 int[] onesA = { 1, 2, 5, 7, 8, 9, 12, 16, 18, 19, 21, 24, 27, 28, 29 }; for (int i = 0; i < onesA.size(); i++) { a.Set(onesA[i]); } Int64BitSet b = new Int64BitSet(30); // 0110000001001000101101001001110...0 int[] onesB = { 1, 2, 9, 12, 16, 18, 19, 21, 24, 27, 28, 29 }; for (int i = 0; i < onesB.size(); i++) { b.Set(onesB[i]); } a.Clear(5, 9); Assert.True(a.Equals(b)); a.Clear(9, 10); Assert.False(a.Equals(b)); a.Set(9); Assert.True(a.Equals(b)); }
internal virtual void DoPrevSetBit(BitArray a, Int64BitSet b) { int aa = a.Length + Random.Next(100); long bb = aa; do { //aa = a.PrevSetBit(aa-1); aa--; while ((aa >= 0) && (!a.SafeGet(aa))) { aa--; } if (b.Length == 0) { bb = -1; } else if (bb > b.Length - 1) { bb = b.PrevSetBit(b.Length - 1); } else if (bb < 1) { bb = -1; } else { bb = bb >= 1 ? b.PrevSetBit(bb - 1) : -1; } Assert.AreEqual(aa, bb); } while (aa >= 0); }
/// <summary> /// this = this AND NOT other </summary> public void AndNot(Int64BitSet other) { int pos = Math.Min(numWords, other.bits.Length); while (--pos >= 0) { bits[pos] &= ~other.bits[pos]; } }
public LongRangeBuilderAnonymousClass(long lower, long upper, bool useBitSet, Int64BitSet bits, IEnumerator <long> neededBounds, IEnumerator <int> neededShifts) { this.lower = lower; this.upper = upper; this.useBitSet = useBitSet; this.bits = bits; this.neededBounds = neededBounds; this.neededShifts = neededShifts; }
public LongRangeBuilderAnonymousInnerClassHelper(TestNumericUtils outerInstance, long lower, long upper, bool useBitSet, Int64BitSet bits, IEnumerator <long> neededBounds, IEnumerator <int> neededShifts) { this.OuterInstance = outerInstance; this.Lower = lower; this.Upper = upper; this.UseBitSet = useBitSet; this.Bits = bits; this.NeededBounds = neededBounds; this.NeededShifts = neededShifts; }
/// <summary> /// this = this XOR other </summary> public void Xor(Int64BitSet other) { Debug.Assert(other.numWords <= numWords, "numWords=" + numWords + ", other.numWords=" + other.numWords); int pos = Math.Min(numWords, other.numWords); while (--pos >= 0) { bits[pos] ^= other.bits[pos]; } }
internal virtual void DoNextSetBit(BitArray a, Int64BitSet b) { int aa = -1; long bb = -1; do { aa = a.NextSetBit(aa + 1); bb = bb < b.Length - 1 ? b.NextSetBit(bb + 1) : -1; Assert.AreEqual(aa, bb); } while (aa >= 0); }
internal virtual void DoGet(BitArray a, Int64BitSet b) { long max = b.Length; for (int i = 0; i < max; i++) { if (a.SafeGet(i) != b.Get(i)) { Assert.Fail("mismatch: BitSet=[" + i + "]=" + a.SafeGet(i)); } } }
/// <summary> /// this = this AND other </summary> public void And(Int64BitSet other) { int pos = Math.Min(numWords, other.numWords); while (--pos >= 0) { bits[pos] &= other.bits[pos]; } if (numWords > other.numWords) { Arrays.Fill(bits, other.numWords, numWords, 0L); } }
/// <summary> /// this = this OR other </summary> public void Or(Int64BitSet other) { if (Debugging.AssertsEnabled) { Debugging.Assert(other.numWords <= numWords, () => "numWords=" + numWords + ", other.numWords=" + other.numWords); } int pos = Math.Min(numWords, other.numWords); while (--pos >= 0) { bits[pos] |= other.bits[pos]; } }
/// <summary> /// this = this XOR other </summary> public void Xor(Int64BitSet other) { if (Debugging.AssertsEnabled) { Debugging.Assert(other.numWords <= numWords, "numWords={0}, other.numWords={1}", numWords, other.numWords); } int pos = Math.Min(numWords, other.numWords); while (--pos >= 0) { bits[pos] ^= other.bits[pos]; } }
/// <summary> /// Returns <c>true</c> if the sets have any elements in common </summary> public bool Intersects(Int64BitSet other) { int pos = Math.Min(numWords, other.numWords); while (--pos >= 0) { if ((bits[pos] & other.bits[pos]) != 0) { return(true); } } return(false); }
// INFO: Tests for trieCodeLong()/trieCodeInt() not needed because implicitely tested by range filter tests /// <summary> /// Note: The neededBounds Iterable must be unsigned (easier understanding what's happening) </summary> private void AssertLongRangeSplit(long lower, long upper, int precisionStep, bool useBitSet, IEnumerable <long> expectedBounds, IEnumerable <int> expectedShifts) { // Cannot use FixedBitSet since the range could be long: Int64BitSet bits = useBitSet ? new Int64BitSet(upper - lower + 1) : null; IEnumerator <long> neededBounds = (expectedBounds == null) ? null : expectedBounds.GetEnumerator(); IEnumerator <int> neededShifts = (expectedShifts == null) ? null : expectedShifts.GetEnumerator(); NumericUtils.SplitInt64Range(new LongRangeBuilderAnonymousInnerClassHelper(this, lower, upper, useBitSet, bits, neededBounds, neededShifts), precisionStep, lower, upper); if (useBitSet) { // after flipping all bits in the range, the cardinality should be zero bits.Flip(0, upper - lower + 1); Assert.AreEqual(0, bits.Cardinality(), "The sub-range concenated should match the whole range"); } }
/// <summary> /// If the given <see cref="Int64BitSet"/> is large enough to hold /// <paramref name="numBits"/>, returns the given <paramref name="bits"/>, otherwise returns a new /// <see cref="Int64BitSet"/> which can hold the requested number of bits. /// /// <para/> /// <b>NOTE:</b> the returned bitset reuses the underlying <see cref="T:long[]"/> of /// the given <paramref name="bits"/> if possible. Also, reading <see cref="Length"/> on the /// returned bits may return a value greater than <paramref name="numBits"/>. /// </summary> public static Int64BitSet EnsureCapacity(Int64BitSet bits, long numBits) { if (numBits < bits.Length) { return(bits); } else { int numWords = Bits2words(numBits); long[] arr = bits.GetBits(); if (numWords >= arr.Length) { arr = ArrayUtil.Grow(arr, numWords + 1); } return(new Int64BitSet(arr, arr.Length << 6)); } }
/// <summary> /// Returns <c>true</c> if both sets have the same bits set </summary> public override bool Equals(object o) { if (this == o) { return(true); } if (!(o is Int64BitSet)) { return(false); } Int64BitSet other = (Int64BitSet)o; if (numBits != other.Length) { return(false); } return(Arrays.Equals(bits, other.bits)); }
public virtual void TestSmallBitSets() { // Make sure size 0-10 bit sets are OK: for (int numBits = 0; numBits < 10; numBits++) { Int64BitSet b1 = new Int64BitSet(numBits); Int64BitSet b2 = new Int64BitSet(numBits); Assert.IsTrue(b1.Equals(b2)); Assert.AreEqual(b1.GetHashCode(), b2.GetHashCode()); Assert.AreEqual(0, b1.Cardinality()); if (numBits > 0) { b1.Set(0, numBits); Assert.AreEqual(numBits, b1.Cardinality()); b1.Flip(0, numBits); Assert.AreEqual(0, b1.Cardinality()); } } }
public virtual void TestHashCodeEquals() { // this test can't handle numBits==0: int numBits = Random().Next(2000) + 1; Int64BitSet b1 = new Int64BitSet(numBits); Int64BitSet b2 = new Int64BitSet(numBits); Assert.IsTrue(b1.Equals(b2)); Assert.IsTrue(b2.Equals(b1)); for (int iter = 0; iter < 10 * RANDOM_MULTIPLIER; iter++) { int idx = Random().Next(numBits); if (!b1.Get(idx)) { b1.Set(idx); Assert.IsFalse(b1.Equals(b2)); Assert.IsFalse(b1.GetHashCode() == b2.GetHashCode()); b2.Set(idx); Assert.AreEqual(b1, b2); Assert.AreEqual(b1.GetHashCode(), b2.GetHashCode()); } } }
private Int64BitSet MakeLongFixedBitSet(int[] a, int numBits) { Int64BitSet bs; if (Random().NextBoolean()) { int bits2words = Int64BitSet.Bits2words(numBits); long[] words = new long[bits2words + Random().Next(100)]; for (int i = bits2words; i < words.Length; i++) { words[i] = Random().NextLong(); } bs = new Int64BitSet(words, numBits); } else { bs = new Int64BitSet(numBits); } foreach (int e in a) { bs.Set(e); } return(bs); }
internal virtual void DoRandomSets(int maxSize, int iter, int mode) { BitArray a0 = null; Int64BitSet b0 = null; for (int i = 0; i < iter; i++) { int sz = TestUtil.NextInt(Random(), 2, maxSize); BitArray a = new BitArray(sz); Int64BitSet b = new Int64BitSet(sz); // test the various ways of setting bits if (sz > 0) { int nOper = Random().Next(sz); for (int j = 0; j < nOper; j++) { int idx; idx = Random().Next(sz); a.SafeSet(idx, true); b.Set(idx); idx = Random().Next(sz); a.SafeSet(idx, false); b.Clear(idx); idx = Random().Next(sz); a.SafeSet(idx, !a.SafeGet(idx)); b.Flip(idx, idx + 1); idx = Random().Next(sz); a.SafeSet(idx, !a.SafeGet(idx)); b.Flip(idx, idx + 1); bool val2 = b.Get(idx); bool val = b.GetAndSet(idx); Assert.IsTrue(val2 == val); Assert.IsTrue(b.Get(idx)); if (!val) { b.Clear(idx); } Assert.IsTrue(b.Get(idx) == val); } } // test that the various ways of accessing the bits are equivalent DoGet(a, b); // test ranges, including possible extension int fromIndex, toIndex; fromIndex = Random().Next(sz / 2); toIndex = fromIndex + Random().Next(sz - fromIndex); BitArray aa = new BitArray(a); aa.Flip(fromIndex, toIndex); Int64BitSet bb = b.Clone(); bb.Flip(fromIndex, toIndex); fromIndex = Random().Next(sz / 2); toIndex = fromIndex + Random().Next(sz - fromIndex); aa = new BitArray(a); aa.Clear(fromIndex, toIndex); bb = b.Clone(); bb.Clear(fromIndex, toIndex); DoNextSetBit(aa, bb); // a problem here is from clear() or nextSetBit DoPrevSetBit(aa, bb); fromIndex = Random().Next(sz / 2); toIndex = fromIndex + Random().Next(sz - fromIndex); aa = new BitArray(a); aa.Set(fromIndex, toIndex); bb = b.Clone(); bb.Set(fromIndex, toIndex); DoNextSetBit(aa, bb); // a problem here is from set() or nextSetBit DoPrevSetBit(aa, bb); if (b0 != null && b0.Length <= b.Length) { Assert.AreEqual(a.Cardinality(), b.Cardinality()); BitArray a_and = new BitArray(a); a_and = a_and.And_UnequalLengths(a0); BitArray a_or = new BitArray(a); a_or = a_or.Or_UnequalLengths(a0); BitArray a_xor = new BitArray(a); a_xor = a_xor.Xor_UnequalLengths(a0); BitArray a_andn = new BitArray(a); a_andn.AndNot(a0); Int64BitSet b_and = b.Clone(); Assert.AreEqual(b, b_and); b_and.And(b0); Int64BitSet b_or = b.Clone(); b_or.Or(b0); Int64BitSet b_xor = b.Clone(); b_xor.Xor(b0); Int64BitSet b_andn = b.Clone(); b_andn.AndNot(b0); Assert.AreEqual(a0.Cardinality(), b0.Cardinality()); Assert.AreEqual(a_or.Cardinality(), b_or.Cardinality()); Assert.AreEqual(a_and.Cardinality(), b_and.Cardinality()); Assert.AreEqual(a_or.Cardinality(), b_or.Cardinality()); Assert.AreEqual(a_xor.Cardinality(), b_xor.Cardinality()); Assert.AreEqual(a_andn.Cardinality(), b_andn.Cardinality()); } a0 = a; b0 = b; } }
public static long Cardinality(this Int64BitSet set) { return(set.Cardinality); }