Return-Path: Delivered-To: apmail-incubator-lucene-net-commits-archive@minotaur.apache.org Received: (qmail 55246 invoked from network); 13 Nov 2009 17:25:02 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.3) by minotaur.apache.org with SMTP; 13 Nov 2009 17:25:02 -0000 Received: (qmail 37423 invoked by uid 500); 13 Nov 2009 17:25:02 -0000 Delivered-To: apmail-incubator-lucene-net-commits-archive@incubator.apache.org Received: (qmail 37367 invoked by uid 500); 13 Nov 2009 17:25:01 -0000 Mailing-List: contact lucene-net-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: lucene-net-dev@incubator.apache.org Delivered-To: mailing list lucene-net-commits@incubator.apache.org Received: (qmail 37355 invoked by uid 99); 13 Nov 2009 17:25:01 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 13 Nov 2009 17:25:01 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 13 Nov 2009 17:24:50 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id 6ECC523888E8; Fri, 13 Nov 2009 17:24:28 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r835931 - in /incubator/lucene.net/trunk/C#/src: Lucene.Net/SupportClass.cs Lucene.Net/Util/OpenBitSet.cs Lucene.Net/Util/OpenBitSetIterator.cs Test/Util/TestOpenBitSet.cs Date: Fri, 13 Nov 2009 17:24:28 -0000 To: lucene-net-commits@incubator.apache.org From: aroush@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20091113172428.6ECC523888E8@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Author: aroush Date: Fri Nov 13 17:24:28 2009 New Revision: 835931 URL: http://svn.apache.org/viewvc?rev=835931&view=rev Log: Fixed NUnit test-cases for: TestOpenBitSet Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/SupportClass.cs incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSetIterator.cs incubator/lucene.net/trunk/C#/src/Test/Util/TestOpenBitSet.cs Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/SupportClass.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/SupportClass.cs?rev=835931&r1=835930&r2=835931&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/SupportClass.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/SupportClass.cs Fri Nov 13 17:24:28 2009 @@ -622,10 +622,7 @@ /// The resulting number from the shift operation public static int URShift(int number, int bits) { - if (number >= 0) - return number >> bits; - else - return (number >> bits) + (2 << ~bits); + return (int) (((uint) number) >> bits); } @@ -637,10 +634,7 @@ /// The resulting number from the shift operation public static long URShift(long number, int bits) { - if (number >= 0) - return number >> bits; - else - return (number >> bits) + (2 << ~bits); + return (long) (((ulong) number) >> bits); } Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/OpenBitSet.cs?rev=835931&r1=835930&r2=835931&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs Fri Nov 13 17:24:28 2009 @@ -246,7 +246,7 @@ { int i = index >> 6; // div 64 int bit = index & 0x3f; // mod 64 - return ((int) (SupportClass.Number.URShift(bits[i], bit))) & 0x01; + return ((int )((ulong) (bits[i]) >> bit)) & 0x01; } @@ -310,7 +310,7 @@ int endWord = ExpandingWordNum(endIndex - 1); long startmask = - 1L << (int) startIndex; - long endmask = SupportClass.Number.URShift(- 1L, (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap + long endmask = (long) (0xffffffffffffffffUL >> (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap if (startWord == endWord) { @@ -399,7 +399,7 @@ int endWord = ((endIndex - 1) >> 6); long startmask = - 1L << startIndex; - long endmask = SupportClass.Number.URShift(- 1L, - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap + long endmask = (long) (0xffffffffffffffffUL >> - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap // invert masks since we are clearing startmask = ~ startmask; @@ -444,7 +444,7 @@ int endWord = (int) ((endIndex - 1) >> 6); long startmask = - 1L << (int) startIndex; - long endmask = SupportClass.Number.URShift(- 1L, (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap + long endmask = (long) (0xffffffffffffffffUL >> (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap // invert masks since we are clearing startmask = ~ startmask; @@ -575,7 +575,7 @@ ***/ long startmask = - 1L << (int) startIndex; - long endmask = SupportClass.Number.URShift(- 1L, (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap + long endmask = (long) (0xffffffffffffffffUL >> (int) - endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap if (startWord == endWord) { @@ -712,11 +712,11 @@ /// public virtual long NextSetBit(long index) { - int i = (int) (SupportClass.Number.URShift(index, 6)); + int i = (int) (index >> 6); if (i >= wlen) return - 1; int subIndex = (int) index & 0x3f; // index within the word - long word = SupportClass.Number.URShift(bits[i], subIndex); // skip all the bits to the right of index + long word = (long) ((ulong) bits[i] >> subIndex); // skip all the bits to the right of index if (word != 0) { @@ -895,7 +895,7 @@ ///

returns the number of 64 bit words it would take to hold numBits

public static int Bits2words(long numBits) { - return (int) ((SupportClass.Number.URShift((numBits - 1), 6)) + 1); + return (int) ((((numBits - 1) >> 6)) + 1); } @@ -941,7 +941,7 @@ for (int i = bits.Length; --i >= 0; ) { h ^= bits[i]; - h = (h << 1) | (SupportClass.Number.URShift(h, 63)); // rotate left + h = (h << 1) | ((long) ((ulong) h >> 63)); // rotate left } return (int) ((h >> 32) ^ h); // fold leftmost bits into right } Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSetIterator.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/OpenBitSetIterator.cs?rev=835931&r1=835930&r2=835931&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSetIterator.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSetIterator.cs Fri Nov 13 17:24:28 2009 @@ -37,8 +37,8 @@ // packed inside a 32 bit integer (8 4 bit numbers). That // should be faster than accessing an array for each index, and // the total array size is kept smaller (256*sizeof(int))=1K - protected internal static readonly int[] bitlist = new int[]{0x0, 0x1, 0x2, 0x21, 0x3, 0x31, 0x32, 0x321, 0x4, 0x41, 0x42, 0x421, 0x43, 0x431, 0x432, 0x4321, 0x5, 0x51, 0x52, 0x521, 0x53, 0x531, 0x532, 0x5321, 0x54, 0x541, 0x542, 0x5421, 0x543, 0x5431, 0x5432, 0x54321, 0x6, 0x61, 0x62, 0x621, 0x63, 0x631, 0x632, 0x6321, 0x64, 0x641, 0x642, 0x6421, 0x643, 0x6431, 0x6432, 0x64321, 0x65, 0x651, 0x652, 0x6521, 0x653, 0x6531, 0x6532, 0x65321, 0x654, 0x6541, 0x6542, 0x65421, 0x6543, 0x65431, 0x65432, 0x654321, 0x7, 0x71, 0x72, 0x721, 0x73, 0x731, 0x732, 0x7321, 0x74, 0x741, 0x742, 0x7421, 0x743, 0x7431, 0x7432, 0x74321, 0x75, 0x751, 0x752, 0x7521, 0x753, 0x7531, 0x7532, 0x75321, 0x754, 0x7541, 0x7542, 0x75421, 0x7543, 0x75431, 0x75432, 0x754321, 0x76, 0x761, 0x762, 0x7621, 0x763, 0x7631, 0x7632, 0x76321, 0x764, 0x7641, 0x7642, 0x76421, 0x7643, 0x76431, 0x76432, 0x764321, 0x765, 0x7651, 0x7652, 0x76521, 0x7653, 0x76531, 0x76532, 0x765321, 0x7654, 0x76541, 0x76542, 0x765421, 0x765 43, 0x765431, 0x765432, 0x7654321, 0x8, 0x81, 0x82, 0x821, 0x83, 0x831, 0x832, 0x8321, 0x84, 0x841, 0x842, 0x8421, 0x843, 0x8431, 0x8432, 0x84321, 0x85, 0x851, 0x852, 0x8521, 0x853, 0x8531, 0x8532, 0x85321, 0x854, 0x8541, 0x8542, 0x85421, 0x8543, 0x85431, 0x85432, 0x854321, 0x86, 0x861, 0x862, 0x8621, 0x863, 0x8631, 0x8632, 0x86321, 0x864, 0x8641, 0x8642, 0x86421, 0x8643, 0x86431, 0x86432, 0x864321, 0x865, 0x8651, 0x8652, 0x86521, 0x8653, 0x86531, 0x86532, 0x865321, 0x8654, 0x86541, 0x86542, 0x865421, 0x86543, 0x865431, 0x865432, 0x8654321, 0x87, 0x871, 0x872, 0x8721, 0x873, 0x8731, 0x8732, 0x87321, 0x874, 0x8741, 0x8742, 0x87421, 0x8743, 0x87431, 0x87432, 0x874321, 0x875, 0x8751, 0x8752, 0x87521, 0x8753, 0x87531, 0x87532, 0x875321, 0x8754, 0x87541, 0x87542, 0x875421, 0x87543, 0x875431, 0x875432, 0x8754321, 0x876, 0x8761, 0x8762, 0x87621, 0x8763, 0x87631, 0x87632, 0x876321, 0x8764, 0x87641, 0x87642, 0x876421, 0x87643, 0x876431, 0x876432, 0x8764321, 0x8765, 0x87651, 0x87652, 0x876521, 0x87653, 0x876531, 0x876532, 0x8765321, 0x87654, - 0x876541, 0x876542, 0x8765421, 0x876543, 0x8765431, 0x8765432, unchecked((int) 0x87654321)}; + protected internal static readonly uint[] bitlist = new uint[]{0x0, 0x1, 0x2, 0x21, 0x3, 0x31, 0x32, 0x321, 0x4, 0x41, 0x42, 0x421, 0x43, 0x431, 0x432, 0x4321, 0x5, 0x51, 0x52, 0x521, 0x53, 0x531, 0x532, 0x5321, 0x54, 0x541, 0x542, 0x5421, 0x543, 0x5431, 0x5432, 0x54321, 0x6, 0x61, 0x62, 0x621, 0x63, 0x631, 0x632, 0x6321, 0x64, 0x641, 0x642, 0x6421, 0x643, 0x6431, 0x6432, 0x64321, 0x65, 0x651, 0x652, 0x6521, 0x653, 0x6531, 0x6532, 0x65321, 0x654, 0x6541, 0x6542, 0x65421, 0x6543, 0x65431, 0x65432, 0x654321, 0x7, 0x71, 0x72, 0x721, 0x73, 0x731, 0x732, 0x7321, 0x74, 0x741, 0x742, 0x7421, 0x743, 0x7431, 0x7432, 0x74321, 0x75, 0x751, 0x752, 0x7521, 0x753, 0x7531, 0x7532, 0x75321, 0x754, 0x7541, 0x7542, 0x75421, 0x7543, 0x75431, 0x75432, 0x754321, 0x76, 0x761, 0x762, 0x7621, 0x763, 0x7631, 0x7632, 0x76321, 0x764, 0x7641, 0x7642, 0x76421, 0x7643, 0x76431, 0x76432, 0x764321, 0x765, 0x7651, 0x7652, 0x76521, 0x7653, 0x76531, 0x76532, 0x765321, 0x7654, 0x76541, 0x76542, 0x765421, 0x7 6543, 0x765431, 0x765432, 0x7654321, 0x8, 0x81, 0x82, 0x821, 0x83, 0x831, 0x832, 0x8321, 0x84, 0x841, 0x842, 0x8421, 0x843, 0x8431, 0x8432, 0x84321, 0x85, 0x851, 0x852, 0x8521, 0x853, 0x8531, 0x8532, 0x85321, 0x854, 0x8541, 0x8542, 0x85421, 0x8543, 0x85431, 0x85432, 0x854321, 0x86, 0x861, 0x862, 0x8621, 0x863, 0x8631, 0x8632, 0x86321, 0x864, 0x8641, 0x8642, 0x86421, 0x8643, 0x86431, 0x86432, 0x864321, 0x865, 0x8651, 0x8652, 0x86521, 0x8653, 0x86531, 0x86532, 0x865321, 0x8654, 0x86541, 0x86542, 0x865421, 0x86543, 0x865431, 0x865432, 0x8654321, 0x87, 0x871, 0x872, 0x8721, 0x873, 0x8731, 0x8732, 0x87321, 0x874, 0x8741, 0x8742, 0x87421, 0x8743, 0x87431, 0x87432, 0x874321, 0x875, 0x8751, 0x8752, 0x87521, 0x8753, 0x87531, 0x87532, 0x875321, 0x8754, 0x87541, 0x87542, 0x875421, 0x87543, 0x875431, 0x875432, 0x8754321, 0x876, 0x8761, 0x8762, 0x87621, 0x8763, 0x87631, 0x87632, 0x876321, 0x8764, 0x87641, 0x87642, 0x876421, 0x87643, 0x876431, 0x876432, 0x8764321, 0x8765, 0x87651, 0x87652 , 0x876521, 0x87653, 0x876531, 0x876532, 0x8765321, 0x87654, + 0x876541, 0x876542, 0x8765421, 0x876543, 0x8765431, 0x8765432, 0x87654321}; ///

** the python code that generated bitlist /// def bits2int(val): /// arr=0 @@ -81,17 +81,17 @@ { if ((int) word == 0) { - wordShift += 32; word = SupportClass.Number.URShift(word, 32); + wordShift += 32; word = (long) ((ulong) word >> 32); } if ((word & 0x0000FFFF) == 0) { - wordShift += 16; word = SupportClass.Number.URShift(word, 16); + wordShift += 16; word = (long) ((ulong) word >> 16); } if ((word & 0x000000FF) == 0) { - wordShift += 8; word = SupportClass.Number.URShift(word, 8); + wordShift += 8; word = (long) ((ulong) word >> 8); } - indexArray = bitlist[(int) word & 0xff]; + indexArray = (int) bitlist[word & 0xff]; } ///

** alternate shift implementations @@ -129,7 +129,7 @@ { if (word != 0) { - word = SupportClass.Number.URShift(word, 8); + word = (long) ((ulong) word >> 8); wordShift += 8; } @@ -149,7 +149,7 @@ } int bitIndex = (indexArray & 0x0f) + wordShift; - indexArray = SupportClass.Number.URShift(indexArray, 4); + indexArray = (int) ((uint) indexArray >> 4); // should i<<6 be cached as a separate variable? // it would only save one cycle in the best circumstances. return curDocId = (i << 6) + bitIndex; @@ -172,7 +172,7 @@ return curDocId = NO_MORE_DOCS; } wordShift = target & 0x3f; - word = SupportClass.Number.URShift(arr[i], wordShift); + word = (long) ((ulong) arr[i] >> wordShift); if (word != 0) { wordShift--; // compensate for 1 based arrIndex @@ -193,7 +193,7 @@ Shift(); int bitIndex = (indexArray & 0x0f) + wordShift; - indexArray = SupportClass.Number.URShift(indexArray, 4); + indexArray = (int) ((uint) indexArray >> 4); // should i<<6 be cached as a separate variable? // it would only save one cycle in the best circumstances. return curDocId = (i << 6) + bitIndex; Modified: incubator/lucene.net/trunk/C#/src/Test/Util/TestOpenBitSet.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Util/TestOpenBitSet.cs?rev=835931&r1=835930&r2=835931&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Test/Util/TestOpenBitSet.cs (original) +++ incubator/lucene.net/trunk/C#/src/Test/Util/TestOpenBitSet.cs Fri Nov 13 17:24:28 2009 @@ -98,7 +98,7 @@ for (int i = 0; i < iter; i++) { int sz = rand.Next(maxSize); - System.Collections.BitArray a = new System.Collections.BitArray((sz % 64 == 0?sz / 64:sz / 64 + 1) * 64); + System.Collections.BitArray a = new System.Collections.BitArray(sz); OpenBitSet b = new OpenBitSet(sz); // test the various ways of setting bits @@ -136,65 +136,174 @@ // test that the various ways of accessing the bits are equivalent DoGet(a, b); - // test ranges, including possible extension - int fromIndex, toIndex; - fromIndex = rand.Next(sz + 80); - toIndex = fromIndex + rand.Next((sz >> 1) + 1); - System.Collections.BitArray aa = (System.Collections.BitArray) a.Clone(); for (int j = fromIndex; j < toIndex; i++) aa.Set(j, !aa.Get(j)); - OpenBitSet bb = (OpenBitSet) b.Clone(); bb.Flip(fromIndex, toIndex); - - DoIterate(aa, bb, mode); // a problem here is from flip or doIterate - - fromIndex = rand.Next(sz + 80); - toIndex = fromIndex + rand.Next((sz >> 1) + 1); - aa = (System.Collections.BitArray) a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, false); - bb = (OpenBitSet) b.Clone(); bb.Clear(fromIndex, toIndex); - - DoNextSetBit(aa, bb); // a problem here is from clear() or nextSetBit - - fromIndex = rand.Next(sz + 80); - toIndex = fromIndex + rand.Next((sz >> 1) + 1); - aa = (System.Collections.BitArray) a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, true); - bb = (OpenBitSet) b.Clone(); bb.Set(fromIndex, toIndex); + // {{dougsale-2.4.0}} + // + // Java's java.util.BitSet automatically grows as needed - i.e., when a bit is referenced beyond + // the size of the BitSet, an exception isn't thrown - rather, the set grows to the size of the + // referenced bit. + // + // System.Collections.BitArray does not have this feature, and thus I've faked it here by + // "growing" the array explicitly when necessary (creating a new instance of the appropriate size + // and setting the appropriate bits). + // + + // test ranges, including possible extension + int fromIndex, toIndex; + fromIndex = rand.Next(sz + 80); + toIndex = fromIndex + rand.Next((sz >> 1) + 1); + + // {{dougsale-2.4.0}}: + // The following commented-out, compound statement's 'for loop' implicitly grows the Java BitSets 'a' + // and 'aa' to the same cardinality as 'j+1' when 'a.Count < j+1' and 'fromIndex < toIndex': + //BitArray aa = (BitArray)a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, !a.Get(j)); + // So, if necessary, lets explicitly grow 'a' now; then 'a' and its clone, 'aa', will be of the required size. + if (a.Count < toIndex && fromIndex < toIndex) + { + System.Collections.BitArray tmp = new System.Collections.BitArray(toIndex, false); + for (int k = 0; k < a.Count; k++) + tmp.Set(k, a.Get(k)); + a = tmp; + } + // {{dougsale-2.4.0}}: now we can invoke this statement without going 'out-of-bounds' + System.Collections.BitArray aa = (System.Collections.BitArray)a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, !a.Get(j)); + OpenBitSet bb = (OpenBitSet)b.Clone(); bb.Flip(fromIndex, toIndex); + + DoIterate(aa, bb, mode); // a problem here is from flip or doIterate + + fromIndex = rand.Next(sz + 80); + toIndex = fromIndex + rand.Next((sz >> 1) + 1); + // {{dougsale-2.4.0}}: + // The following commented-out, compound statement's 'for loop' implicitly grows the Java BitSet 'aa' + // when 'a.Count < j+1' and 'fromIndex < toIndex' + //aa = (BitArray)a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, false); + // So, if necessary, lets explicitly grow 'aa' now + if (a.Count < toIndex && fromIndex < toIndex) + { + aa = new System.Collections.BitArray(toIndex); + for (int k = 0; k < a.Count; k++) + aa.Set(k, a.Get(k)); + } + else + { + aa = (System.Collections.BitArray)a.Clone(); + } + for (int j = fromIndex; j < toIndex; j++) aa.Set(j, false); + bb = (OpenBitSet)b.Clone(); bb.Clear(fromIndex, toIndex); + + DoNextSetBit(aa, bb); // a problem here is from clear() or nextSetBit + + fromIndex = rand.Next(sz + 80); + toIndex = fromIndex + rand.Next((sz >> 1) + 1); + // {{dougsale-2.4.0}}: + // The following commented-out, compound statement's 'for loop' implicitly grows the Java BitSet 'aa' + // when 'a.Count < j+1' and 'fromIndex < toIndex' + //aa = (BitArray)a.Clone(); for (int j = fromIndex; j < toIndex; j++) aa.Set(j, false); + // So, if necessary, lets explicitly grow 'aa' now + if (a.Count < toIndex && fromIndex < toIndex) + { + aa = new System.Collections.BitArray(toIndex); + for (int k = 0; k < a.Count; k++) + aa.Set(k, a.Get(k)); + } + else + { + aa = (System.Collections.BitArray)a.Clone(); + } + for (int j = fromIndex; j < toIndex; j++) aa.Set(j, true); + bb = (OpenBitSet)b.Clone(); bb.Set(fromIndex, toIndex); DoNextSetBit(aa, bb); // a problem here is from set() or nextSetBit if (a0 != null) { - Assert.AreEqual(a.Equals(a0), b.Equals(b0)); - - Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a), b.Cardinality()); - - System.Collections.BitArray a_and = (System.Collections.BitArray) a.Clone(); - a_and.And(a0); - System.Collections.BitArray a_or = (System.Collections.BitArray) a.Clone(); - a_or.Or(a0); - System.Collections.BitArray a_xor = (System.Collections.BitArray) a.Clone(); - a_xor.Xor(a0); - System.Collections.BitArray a_andn = (System.Collections.BitArray) a.Clone(); a_andn.And(a0.Not()); - - OpenBitSet b_and = (OpenBitSet) b.Clone(); Assert.AreEqual(b, b_and); b_and.And(b0); - OpenBitSet b_or = (OpenBitSet) b.Clone(); b_or.Or(b0); - OpenBitSet b_xor = (OpenBitSet) b.Clone(); b_xor.Xor(b0); - OpenBitSet b_andn = (OpenBitSet) b.Clone(); b_andn.AndNot(b0); - - DoIterate(a_and, b_and, mode); - DoIterate(a_or, b_or, mode); - DoIterate(a_xor, b_xor, mode); - DoIterate(a_andn, b_andn, mode); - - Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_and), b_and.Cardinality()); - Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_or), b_or.Cardinality()); - Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_xor), b_xor.Cardinality()); - Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_andn), b_andn.Cardinality()); - - // test non-mutating popcounts - Assert.AreEqual(b_and.Cardinality(), OpenBitSet.IntersectionCount(b, b0)); - Assert.AreEqual(b_or.Cardinality(), OpenBitSet.UnionCount(b, b0)); - Assert.AreEqual(b_xor.Cardinality(), OpenBitSet.XorCount(b, b0)); - Assert.AreEqual(b_andn.Cardinality(), OpenBitSet.AndNotCount(b, b0)); - } + Assert.AreEqual(a.Equals(a0), b.Equals(b0)); + + Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a), b.Cardinality()); + + // {{dougsale-2.4.0}} + // + // The Java code used java.util.BitSet, which grows as needed. + // When a bit, outside the dimension of the set is referenced, + // the set automatically grows to the necessary size. The + // new entries default to false. + // + // BitArray does not grow automatically and is not growable. + // Thus when BitArray instances of mismatched cardinality + // interact, we must first explicitly "grow" the smaller one. + // + // This growth is acheived by creating a new instance of the + // required size and copying the appropriate values. + // + + //BitArray a_and = (BitArray)a.Clone(); a_and.And(a0); + //BitArray a_or = (BitArray)a.Clone(); a_or.Or(a0); + //BitArray a_xor = (BitArray)a.Clone(); a_xor.Xor(a0); + //BitArray a_andn = (BitArray)a.Clone(); for (int j = 0; j < a_andn.Count; j++) if (a0.Get(j)) a_andn.Set(j, false); + + System.Collections.BitArray a_and; + System.Collections.BitArray a_or; + System.Collections.BitArray a_xor; + System.Collections.BitArray a_andn; + + if (a.Count < a0.Count) + { + // the Java code would have implicitly resized 'a_and', 'a_or', 'a_xor', and 'a_andn' + // in this case, so we explicitly create a resized stand-in for 'a' here, allowing for + // a to keep its original size while 'a_and', 'a_or', 'a_xor', and 'a_andn' are resized + System.Collections.BitArray tmp = new System.Collections.BitArray(a0.Count, false); + for (int z = 0; z < a.Count; z++) + tmp.Set(z, a.Get(z)); + + a_and = (System.Collections.BitArray)tmp.Clone(); a_and.And(a0); + a_or = (System.Collections.BitArray)tmp.Clone(); a_or.Or(a0); + a_xor = (System.Collections.BitArray)tmp.Clone(); a_xor.Xor(a0); + a_andn = (System.Collections.BitArray)tmp.Clone(); for (int j = 0; j < a_andn.Count; j++) if (a0.Get(j)) a_andn.Set(j, false); + } + else if (a.Count > a0.Count) + { + // the Java code would have implicitly resized 'a0' in this case, so + // we explicitly do so here: + System.Collections.BitArray tmp = new System.Collections.BitArray(a.Count, false); + for (int z = 0; z < a0.Count; z++) + tmp.Set(z, a0.Get(z)); + a0 = tmp; + + a_and = (System.Collections.BitArray)a.Clone(); a_and.And(a0); + a_or = (System.Collections.BitArray)a.Clone(); a_or.Or(a0); + a_xor = (System.Collections.BitArray)a.Clone(); a_xor.Xor(a0); + a_andn = (System.Collections.BitArray)a.Clone(); for (int j = 0; j < a_andn.Count; j++) if (a0.Get(j)) a_andn.Set(j, false); + } + else + { + // 'a' and 'a0' are the same size, no explicit growing necessary + a_and = (System.Collections.BitArray)a.Clone(); a_and.And(a0); + a_or = (System.Collections.BitArray)a.Clone(); a_or.Or(a0); + a_xor = (System.Collections.BitArray)a.Clone(); a_xor.Xor(a0); + a_andn = (System.Collections.BitArray)a.Clone(); for (int j = 0; j < a_andn.Count; j++) if (a0.Get(j)) a_andn.Set(j, false); + } + + OpenBitSet b_and = (OpenBitSet)b.Clone(); Assert.AreEqual(b, b_and); b_and.And(b0); + OpenBitSet b_or = (OpenBitSet)b.Clone(); b_or.Or(b0); + OpenBitSet b_xor = (OpenBitSet)b.Clone(); b_xor.Xor(b0); + OpenBitSet b_andn = (OpenBitSet)b.Clone(); b_andn.AndNot(b0); + + DoIterate(a_and, b_and, mode); + DoIterate(a_or, b_or, mode); + DoIterate(a_xor, b_xor, mode); + DoIterate(a_andn, b_andn, mode); + + Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_and), b_and.Cardinality()); + Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_or), b_or.Cardinality()); + Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_xor), b_xor.Cardinality()); + Assert.AreEqual(SupportClass.BitSetSupport.Cardinality(a_andn), b_andn.Cardinality()); + + // test non-mutating popcounts + Assert.AreEqual(b_and.Cardinality(), OpenBitSet.IntersectionCount(b, b0)); + Assert.AreEqual(b_or.Cardinality(), OpenBitSet.UnionCount(b, b0)); + Assert.AreEqual(b_xor.Cardinality(), OpenBitSet.XorCount(b, b0)); + Assert.AreEqual(b_andn.Cardinality(), OpenBitSet.AndNotCount(b, b0)); + } a0 = a; b0 = b;