@@ -460,6 +460,10 @@ impl<T: Idx> ChunkedBitSet<T> {
460460 self.chunks.iter().map(|chunk| chunk.count()).sum()
461461 }
462462
463+ pub fn is_empty(&self) -> bool {
464+ self.chunks.iter().all(|chunk| matches!(chunk, Chunk::Zeros(..) | Chunk::Ones(0)))
465+ }
466+
463467 /// Returns `true` if `self` contains `elem`.
464468 #[inline]
465469 pub fn contains(&self, elem: T) -> bool {
@@ -668,12 +672,138 @@ impl<T: Idx> BitRelations<ChunkedBitSet<T>> for ChunkedBitSet<T> {
668672 changed
669673 }
670674
671- fn subtract(&mut self, _other: &ChunkedBitSet<T>) -> bool {
672- unimplemented!("implement if/when necessary");
675+ fn subtract(&mut self, other: &ChunkedBitSet<T>) -> bool {
676+ assert_eq!(self.domain_size, other.domain_size);
677+ debug_assert_eq!(self.chunks.len(), other.chunks.len());
678+
679+ let mut changed = false;
680+ for (mut self_chunk, other_chunk) in self.chunks.iter_mut().zip(other.chunks.iter()) {
681+ match (&mut self_chunk, &other_chunk) {
682+ (Zeros(..), _) | (_, Zeros(..)) => {}
683+ (Ones(self_chunk_domain_size), Ones(other_chunk_domain_size)) => {
684+ debug_assert_eq!(self_chunk_domain_size, other_chunk_domain_size);
685+ changed = true;
686+ *self_chunk = Zeros(*self_chunk_domain_size);
687+ }
688+ (_, Ones(_)) => {}
689+ (
690+ Ones(self_chunk_domain_size),
691+ Mixed(other_chunk_domain_size, other_chunk_count, other_chunk_words),
692+ ) => {
693+ debug_assert_eq!(self_chunk_domain_size, other_chunk_domain_size);
694+ changed = true;
695+ let num_words = num_words(*self_chunk_domain_size as usize);
696+ debug_assert!(num_words > 0 && num_words <= CHUNK_WORDS);
697+ let mut tail_mask =
698+ 1 << (*other_chunk_domain_size - ((num_words - 1) * WORD_BITS) as u16) - 1;
699+ let mut self_chunk_words = **other_chunk_words;
700+ for word in self_chunk_words[0..num_words].iter_mut().rev() {
701+ *word = !*word & tail_mask;
702+ tail_mask = u64::MAX;
703+ }
704+ let self_chunk_count = *self_chunk_domain_size - *other_chunk_count;
705+ debug_assert_eq!(
706+ self_chunk_count,
707+ self_chunk_words[0..num_words]
708+ .iter()
709+ .map(|w| w.count_ones() as ChunkSize)
710+ .sum()
711+ );
712+ *self_chunk =
713+ Mixed(*self_chunk_domain_size, self_chunk_count, Rc::new(self_chunk_words));
714+ }
715+ (
716+ Mixed(
717+ self_chunk_domain_size,
718+ ref mut self_chunk_count,
719+ ref mut self_chunk_words,
720+ ),
721+ Mixed(_other_chunk_domain_size, _other_chunk_count, other_chunk_words),
722+ ) => {
723+ // See [`<Self as BitRelations<ChunkedBitSet<T>>>::union`] for the explanation
724+ let op = |a: u64, b: u64| a & !b;
725+ let num_words = num_words(*self_chunk_domain_size as usize);
726+ if bitwise_changes(
727+ &self_chunk_words[0..num_words],
728+ &other_chunk_words[0..num_words],
729+ op,
730+ ) {
731+ let self_chunk_words = Rc::make_mut(self_chunk_words);
732+ let has_changed = bitwise(
733+ &mut self_chunk_words[0..num_words],
734+ &other_chunk_words[0..num_words],
735+ op,
736+ );
737+ debug_assert!(has_changed);
738+ *self_chunk_count = self_chunk_words[0..num_words]
739+ .iter()
740+ .map(|w| w.count_ones() as ChunkSize)
741+ .sum();
742+ if *self_chunk_count == 0 {
743+ *self_chunk = Zeros(*self_chunk_domain_size);
744+ }
745+ changed = true;
746+ }
747+ }
748+ }
749+ }
750+ changed
673751 }
674752
675- fn intersect(&mut self, _other: &ChunkedBitSet<T>) -> bool {
676- unimplemented!("implement if/when necessary");
753+ fn intersect(&mut self, other: &ChunkedBitSet<T>) -> bool {
754+ assert_eq!(self.domain_size, other.domain_size);
755+ debug_assert_eq!(self.chunks.len(), other.chunks.len());
756+
757+ let mut changed = false;
758+ for (mut self_chunk, other_chunk) in self.chunks.iter_mut().zip(other.chunks.iter()) {
759+ match (&mut self_chunk, &other_chunk) {
760+ (Zeros(..), _) | (_, Ones(..)) => {}
761+ (
762+ Ones(self_chunk_domain_size),
763+ Zeros(other_chunk_domain_size) | Mixed(other_chunk_domain_size, ..),
764+ )
765+ | (Mixed(self_chunk_domain_size, ..), Zeros(other_chunk_domain_size)) => {
766+ debug_assert_eq!(self_chunk_domain_size, other_chunk_domain_size);
767+ changed = true;
768+ *self_chunk = other_chunk.clone();
769+ }
770+ (
771+ Mixed(
772+ self_chunk_domain_size,
773+ ref mut self_chunk_count,
774+ ref mut self_chunk_words,
775+ ),
776+ Mixed(_other_chunk_domain_size, _other_chunk_count, other_chunk_words),
777+ ) => {
778+ // See [`<Self as BitRelations<ChunkedBitSet<T>>>::union`] for the explanation
779+ let op = |a, b| a & b;
780+ let num_words = num_words(*self_chunk_domain_size as usize);
781+ if bitwise_changes(
782+ &self_chunk_words[0..num_words],
783+ &other_chunk_words[0..num_words],
784+ op,
785+ ) {
786+ let self_chunk_words = Rc::make_mut(self_chunk_words);
787+ let has_changed = bitwise(
788+ &mut self_chunk_words[0..num_words],
789+ &other_chunk_words[0..num_words],
790+ op,
791+ );
792+ debug_assert!(has_changed);
793+ *self_chunk_count = self_chunk_words[0..num_words]
794+ .iter()
795+ .map(|w| w.count_ones() as ChunkSize)
796+ .sum();
797+ if *self_chunk_count == 0 {
798+ *self_chunk = Zeros(*self_chunk_domain_size);
799+ }
800+ changed = true;
801+ }
802+ }
803+ }
804+ }
805+
806+ changed
677807 }
678808}
679809
0 commit comments