Lines Matching refs:words
65 * BitSets are packed into arrays of "words." Currently a word is
90 private long[] words;
93 * The number of words in the logical size of this BitSet.
98 * Whether the size of "words" is user-specified. If so, we assume
117 assert(wordsInUse == 0 || words[wordsInUse - 1] != 0);
118 assert(wordsInUse >= 0 && wordsInUse <= words.length);
119 assert(wordsInUse == words.length || words[wordsInUse] == 0);
123 * Sets the field wordsInUse to the logical size in words of the bit set.
124 * WARNING:This method assumes that the number of words actually in use is
131 if (words[i] != 0)
164 words = new long[wordIndex(nbits-1) + 1];
168 * Creates a bit set using words as the internal representation.
171 private BitSet(long[] words) {
172 this.words = words;
173 this.wordsInUse = words.length;
220 long[] words = new long[n];
221 lb.get(words);
222 return new BitSet(words);
265 long[] words = new long[(n + 7) / 8];
269 words[i++] = bb.getLong();
271 words[i] |= (bb.get() & 0xffL) << (8 * j);
272 return new BitSet(words);
293 for (long x = words[n - 1]; x != 0; x >>>= 8)
298 bb.putLong(words[i]);
299 for (long x = words[n - 1]; x != 0; x >>>= 8)
318 return Arrays.copyOf(words, wordsInUse);
322 * Ensures that the BitSet can hold enough words.
323 * @param wordsRequired the minimum acceptable number of words.
326 if (words.length < wordsRequired) {
328 int request = Math.max(2 * words.length, wordsRequired);
329 words = Arrays.copyOf(words, request);
377 words[wordIndex] ^= (1L << bitIndex);
409 words[startWordIndex] ^= (firstWordMask & lastWordMask);
411 // Case 2: Multiple words
413 words[startWordIndex] ^= firstWordMask;
415 // Handle intermediate words, if any
417 words[i] ^= WORD_MASK;
420 words[endWordIndex] ^= lastWordMask;
441 words[wordIndex] |= (1L << bitIndex); // Restores invariants
487 words[startWordIndex] |= (firstWordMask & lastWordMask);
489 // Case 2: Multiple words
491 words[startWordIndex] |= firstWordMask;
493 // Handle intermediate words, if any
495 words[i] = WORD_MASK;
498 words[endWordIndex] |= lastWordMask;
538 words[wordIndex] &= ~(1L << bitIndex);
575 words[startWordIndex] &= ~(firstWordMask & lastWordMask);
577 // Case 2: Multiple words
579 words[startWordIndex] &= ~firstWordMask;
581 // Handle intermediate words, if any
583 words[i] = 0;
586 words[endWordIndex] &= ~lastWordMask;
600 words[--wordsInUse] = 0;
621 && ((words[wordIndex] & (1L << bitIndex)) != 0);
656 // Process all words but the last word
658 result.words[i] = wordAligned ? words[sourceIndex] :
659 (words[sourceIndex] >>> fromIndex) |
660 (words[sourceIndex+1] << -fromIndex);
664 result.words[targetWords - 1] =
666 ? /* straddles source words */
667 ((words[sourceIndex] >>> fromIndex) |
668 (words[sourceIndex+1] & lastWordMask) << -fromIndex)
670 ((words[sourceIndex] & lastWordMask) >>> fromIndex);
709 long word = words[u] & (WORD_MASK << fromIndex);
716 word = words[u];
741 long word = ~words[u] & (WORD_MASK << fromIndex);
748 word = ~words[u];
787 long word = words[u] & (WORD_MASK >>> -(fromIndex+1));
794 word = words[u];
825 long word = ~words[u] & (WORD_MASK >>> -(fromIndex+1));
832 word = ~words[u];
849 (BITS_PER_WORD - Long.numberOfLeadingZeros(words[wordsInUse - 1]));
874 if ((words[i] & set.words[i]) != 0)
888 sum += Long.bitCount(words[i]);
906 words[--wordsInUse] = 0;
908 // Perform logical AND on words in common
910 words[i] &= set.words[i];
936 // Perform logical OR on words in common
938 words[i] |= set.words[i];
940 // Copy any remaining words
942 System.arraycopy(set.words, wordsInCommon,
943 words, wordsInCommon,
972 // Perform logical XOR on words in common
974 words[i] ^= set.words[i];
976 // Copy any remaining words
978 System.arraycopy(set.words, wordsInCommon,
979 words, wordsInCommon,
995 // Perform logical (a & !b) on words in common
997 words[i] &= ~set.words[i];
1012 * long[] words = toLongArray();
1013 * for (int i = words.length; --i >= 0; )
1014 * h ^= words[i] * (i + 1);
1024 h ^= words[i] * (i + 1);
1037 return words.length * BITS_PER_WORD;
1068 // Check words in use by both BitSets
1070 if (words[i] != set.words[i])
1091 result.words = words.clone();
1105 if (wordsInUse != words.length) {
1106 words = Arrays.copyOf(words, wordsInUse);
1124 fields.put("bits", words);
1136 words = (long[]) fields.get("bits", null);
1141 wordsInUse = words.length;
1143 sizeIsSticky = (words.length > 0 && words[words.length-1] == 0L); // heuristic