@@ -262,86 +262,50 @@ fn sparse_intersect<T: Idx>(
262
262
set : & mut SparseBitSet < T > ,
263
263
other_contains : impl Fn ( & T ) -> bool ,
264
264
) -> bool {
265
- let mut changed = false ;
266
- for i in ( 0 ..set. len ( ) ) . rev ( ) {
267
- if !other_contains ( & set. elems [ i] ) {
268
- set. elems . remove ( i) ;
269
- changed = true ;
270
- }
271
- }
272
- changed
273
- }
274
-
275
- impl < T : Idx > BitRelations < SparseBitSet < T > > for BitSet < T > {
276
- fn union ( & mut self , other : & SparseBitSet < T > ) -> bool {
277
- sequential_update ( |elem| self . insert ( elem) , other. iter ( ) . cloned ( ) )
278
- }
279
-
280
- fn subtract ( & mut self , other : & SparseBitSet < T > ) -> bool {
281
- sequential_update ( |elem| self . remove ( elem) , other. iter ( ) . cloned ( ) )
282
- }
283
-
284
- fn intersect ( & mut self , other : & SparseBitSet < T > ) -> bool {
285
- self . intersect ( & other. to_dense ( ) )
286
- }
265
+ let size = set. elems . len ( ) ;
266
+ set. elems . retain ( |elem| other_contains ( elem) ) ;
267
+ set. elems . len ( ) != size
287
268
}
288
269
289
- impl < T : Idx > BitRelations < BitSet < T > > for SparseBitSet < T > {
290
- fn union ( & mut self , other : & BitSet < T > ) -> bool {
291
- sequential_update ( |elem| self . insert ( elem) , other. iter ( ) )
292
- }
293
-
294
- fn subtract ( & mut self , other : & BitSet < T > ) -> bool {
295
- sequential_update ( |elem| self . remove ( elem) , other. iter ( ) )
296
- }
297
-
298
- fn intersect ( & mut self , other : & BitSet < T > ) -> bool {
299
- sparse_intersect ( self , |el| other. contains ( * el) )
300
- }
301
- }
302
-
303
- impl < T : Idx > BitRelations < SparseBitSet < T > > for SparseBitSet < T > {
304
- fn union ( & mut self , other : & SparseBitSet < T > ) -> bool {
305
- sequential_update ( |elem| self . insert ( elem) , other. iter ( ) . cloned ( ) )
306
- }
307
-
308
- fn subtract ( & mut self , other : & SparseBitSet < T > ) -> bool {
309
- sequential_update ( |elem| self . insert ( elem) , other. iter ( ) . cloned ( ) )
310
- }
311
-
312
- fn intersect ( & mut self , other : & SparseBitSet < T > ) -> bool {
313
- sparse_intersect ( self , |el| other. contains ( * el) )
314
- }
315
- }
316
-
317
- impl < T : Idx , S > BitRelations < HybridBitSet < T > > for S
318
- where
319
- S : BitRelations < BitSet < T > > + BitRelations < SparseBitSet < T > > ,
320
- {
270
+ impl < T : Idx > BitRelations < HybridBitSet < T > > for BitSet < T > {
321
271
fn union ( & mut self , other : & HybridBitSet < T > ) -> bool {
272
+ assert_eq ! ( self . domain_size, other. domain_size( ) ) ;
322
273
match other {
323
- HybridBitSet :: Sparse ( sparse) => self . union ( sparse) ,
274
+ HybridBitSet :: Sparse ( sparse) => {
275
+ sequential_update ( |elem| self . insert ( elem) , sparse. iter ( ) . cloned ( ) )
276
+ }
324
277
HybridBitSet :: Dense ( dense) => self . union ( dense) ,
325
278
}
326
279
}
327
280
328
281
fn subtract ( & mut self , other : & HybridBitSet < T > ) -> bool {
282
+ assert_eq ! ( self . domain_size, other. domain_size( ) ) ;
329
283
match other {
330
- HybridBitSet :: Sparse ( sparse) => self . subtract ( sparse) ,
284
+ HybridBitSet :: Sparse ( sparse) => {
285
+ sequential_update ( |elem| self . remove ( elem) , sparse. iter ( ) . cloned ( ) )
286
+ }
331
287
HybridBitSet :: Dense ( dense) => self . subtract ( dense) ,
332
288
}
333
289
}
334
290
335
291
fn intersect ( & mut self , other : & HybridBitSet < T > ) -> bool {
292
+ assert_eq ! ( self . domain_size, other. domain_size( ) ) ;
336
293
match other {
337
- HybridBitSet :: Sparse ( sparse) => self . intersect ( sparse) ,
294
+ HybridBitSet :: Sparse ( sparse) => {
295
+ let n = self . count ( ) ;
296
+ let mut sparse_copy = sparse. clone ( ) ;
297
+ sparse_intersect ( & mut sparse_copy, |el| !self . contains ( * el) ) ;
298
+ * self = sparse_copy. to_dense ( ) ;
299
+ self . count ( ) != n
300
+ }
338
301
HybridBitSet :: Dense ( dense) => self . intersect ( dense) ,
339
302
}
340
303
}
341
304
}
342
305
343
306
impl < T : Idx > BitRelations < HybridBitSet < T > > for HybridBitSet < T > {
344
307
fn union ( & mut self , other : & HybridBitSet < T > ) -> bool {
308
+ assert_eq ! ( self . domain_size( ) , other. domain_size( ) ) ;
345
309
match self {
346
310
HybridBitSet :: Sparse ( self_sparse) => {
347
311
match other {
@@ -385,20 +349,22 @@ impl<T: Idx> BitRelations<HybridBitSet<T>> for HybridBitSet<T> {
385
349
}
386
350
387
351
fn subtract ( & mut self , other : & HybridBitSet < T > ) -> bool {
388
- // FIXME(willcrichton): should there be an optimized sparse / dense version?
352
+ assert_eq ! ( self . domain_size ( ) , other . domain_size ( ) ) ;
389
353
match self {
390
- HybridBitSet :: Sparse ( self_sparse) => self_sparse. subtract ( other) ,
354
+ HybridBitSet :: Sparse ( self_sparse) => {
355
+ sequential_update ( |elem| self_sparse. remove ( elem) , other. iter ( ) )
356
+ }
391
357
HybridBitSet :: Dense ( self_dense) => self_dense. subtract ( other) ,
392
358
}
393
359
}
394
360
395
361
fn intersect ( & mut self , other : & HybridBitSet < T > ) -> bool {
396
- // FIXME(willcrichton): should there be an optimized sparse / dense version?
362
+ assert_eq ! ( self . domain_size ( ) , other . domain_size ( ) ) ;
397
363
match self {
398
- HybridBitSet :: Sparse ( self_sparse) => self_sparse. intersect ( other) ,
399
- HybridBitSet :: Dense ( self_dense) => {
400
- <BitSet < T > as BitRelations < HybridBitSet < T > > >:: intersect ( self_dense, other)
364
+ HybridBitSet :: Sparse ( self_sparse) => {
365
+ sparse_intersect ( self_sparse, |elem| other. contains ( * elem) )
401
366
}
367
+ HybridBitSet :: Dense ( self_dense) => self_dense. intersect ( other) ,
402
368
}
403
369
}
404
370
}
0 commit comments