1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
//! Mutating [`BitSet`] methods.
use crate::*;
impl<W: Word> BitSet<W> {
/// Removes all elements from the set.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![0..23];
/// assert_eq!(set.len(), 23);
/// set.clear();
/// assert_eq!(set.len(), 0);
/// ```
#[inline]
pub fn clear(&mut self) {
self.0 = W::ZERO;
}
/// Insert an element into the set (or leave it in).
///
/// This is the same as `self += e`.
///
/// # Preconditions
///
/// The caller must ensure that `e <= Self::MAX`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1, 3];
/// set.insert(2);
/// assert_eq!(set, set![1..=3]);
/// set.insert(2); // Does nothing.
/// ```
#[inline]
pub fn insert(&mut self, e: Element) {
Self::debug_bound_check(e);
self.0 |= W::ONE << e;
}
/// Removes an element from the set (if it exists).
///
/// This is the same as `self -= e`.
///
/// # Preconditions
///
/// The caller must ensure that `e <= Self::MAX`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=3];
/// set.remove(2);
/// assert_eq!(set, set![1, 3]);
/// set.remove(2); // Does nothing.
/// ```
#[inline]
pub fn remove(&mut self, e: Element) {
Self::debug_bound_check(e);
self.0 &= !(W::ONE << e);
}
/// Toggles the presence of an element in the set.
///
/// # Preconditions
///
/// The caller must ensure that `e <= Self::MAX`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=3];
/// set.toggle(2);
/// assert_eq!(set, set![1, 3]);
/// set.toggle(2);
/// assert_eq!(set, set![1..=3]);
/// ```
#[inline]
pub fn toggle(&mut self, e: Element) {
Self::debug_bound_check(e);
self.0 ^= W::ONE << e;
}
/// Insert every element from another set.
///
/// This is the same as `self |= other`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=5];
/// set.union_update(set![3..=7]);
/// assert_eq!(set, set![1..=7]);
/// ```
#[inline]
pub fn union_update(&mut self, other: Self) {
self.0 |= other.0;
}
/// Remove all elements not present in another set.
///
/// This is the same as `self &= other`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=5];
/// set.intersection_update(set![3..=7]);
/// assert_eq!(set, set![3..=5]);
/// ```
#[inline]
pub fn intersection_update(&mut self, other: Self) {
self.0 &= other.0;
}
/// Remove all elements present in another set.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=5];
/// set.difference_update(set![3..=7]);
/// assert_eq!(set, set![1..=2]);
/// ```
#[inline]
pub fn difference_update(&mut self, other: Self) {
self.0 &= !other.0;
}
/// Toggle all elements present in another set.
///
/// This is the same as `self ^= other`.
///
/// # Examples
///
/// ```
/// # use pibs::prelude::*;
/// let mut set = set![1..=5];
/// set.symmetric_difference_update(set![3..=7]);
/// assert_eq!(set, set![1..=2, 6..=7]);
/// ```
#[inline]
pub fn symmetric_difference_update(&mut self, other: Self) {
self.0 ^= other.0;
}
}