Esempio n. 1
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];
            }
        }
Esempio n. 2
0
        /// <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];
            }
        }
Esempio n. 3
0
        /// <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);
            }
        }
Esempio n. 4
0
        /// <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);
        }
Esempio n. 5
0
        /// <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];
            }
        }
Esempio n. 6
0
        /// <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];
            }
        }
Esempio n. 7
0
 /// <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));
     }
 }
Esempio n. 8
0
        /// <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));
        }
Esempio n. 9
0
 public static long Cardinality(this Int64BitSet set)
 {
     return(set.Cardinality);
 }