Empirical
set_utils.h
Go to the documentation of this file.
1 
12 #ifndef EMP_SET_UTILS_H
13 #define EMP_SET_UTILS_H
14 
15 #include <set>
16 #include <unordered_set>
17 
18 #include "../base/vector.h"
19 
20 namespace emp {
21 
23  template <typename T>
24  void insert(std::set<T> & s1, const std::set<T> & s2) {
25  s1.insert(s2.begin(), s2.end());
26  }
27 
29  template <typename T, typename H>
30  bool Has(const std::set<T,H> & s, const T & val) { return s.count(val); }
31 
33  template <typename T, typename H>
34  bool Has(const std::multiset<T,H> & s, const T & val) { return s.count(val); }
35 
37  template <typename T, typename H>
38  bool Has(const std::unordered_set<T,H> & s, const T & val) { return s.count(val); }
39 
41  template <typename T, typename H>
42  bool Has(const std::unordered_multiset<T,H> & s, const T & val) { return s.count(val); }
43 
44  // Note: the following functions allow the use of sets or vectors. Sets are passed
45  // by reference and vectors are passed by value, because these functions only work
46  // on sorted data. Therefore, vectors must be sorted first, which happens in place.
47 
49  template <typename T>
50  std::set<T> difference(std::set<T> & s1, std::set<T> & s2) {
51  // Based on PierreBdR's answer to https://stackoverflow.com/questions/283977/c-stl-set-difference
52  std::set<T> result;
53  std::set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
54  std::inserter(result, result.end()));
55  return result;
56  }
57 
59  template <typename T>
60  std::set<T> difference(emp::vector<T> s1, emp::vector<T> & s2) {
61  // Based on PierreBdR's answer to https://stackoverflow.com/questions/283977/c-stl-set-difference
62  std::sort(s1.begin(), s1.end()); // set_difference expects sorted things
63  std::sort(s2.begin(), s2.end()); // set_difference expects sorted things
64 
65  std::set<T> result;
66  std::set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
67  std::inserter(result, result.end()));
68  return result;
69  }
70 
72  template <typename T>
73  std::set<T> difference(std::set<T> & s1, emp::vector<T> s2) {
74  // Based on PierreBdR's answer to https://stackoverflow.com/questions/283977/c-stl-set-difference
75  std::sort(s2.begin(), s2.end()); // set_difference expects sorted things
76  std::set<T> result;
77  std::set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
78  std::inserter(result, result.end()));
79  return result;
80  }
81 
83  template <typename T>
84  std::set<T> difference(emp::vector<T> s1, std::set<T> & s2) {
85  // Based on PierreBdR's answer to https://stackoverflow.com/questions/283977/c-stl-set-difference
86  std::sort(s1.begin(), s1.end()); // set_difference expects sorted things
87  std::set<T> result;
88  std::set_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
89  std::inserter(result, result.end()));
90  return result;
91  }
92 
94  template <typename T>
95  std::set<T> intersection(std::set<T> s1, std::set<T> s2) {
96  std::set<T> result;
97  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
98  std::inserter(result, result.end()));
99  return result;
100  }
101 
103  template <typename T>
105  std::sort(s1.begin(), s1.end()); // set_intersection expects sorted things
106  std::sort(s2.begin(), s2.end()); // set_intersection expects sorted things
107 
108  std::set<T> result;
109  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
110  std::inserter(result, result.end()));
111  return result;
112  }
113 
115  template <typename T>
116  std::set<T> intersection(std::set<T> s1, emp::vector<T> s2) {
117  std::sort(s2.begin(), s2.end()); // set_intersection expects sorted things
118 
119  std::set<T> result;
120  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
121  std::inserter(result, result.end()));
122  return result;
123  }
124 
126  template <typename T>
127  std::set<T> intersection(emp::vector<T> s1, std::set<T> s2) {
128  std::sort(s1.begin(), s1.end()); // set_intersection expects sorted things
129 
130  std::set<T> result;
131  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
132  std::inserter(result, result.end()));
133  return result;
134  }
135 
137  template <typename T>
138  std::set<T> set_union(std::set<T> s1, std::set<T> s2) {
139  std::set<T> result;
140  std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
141  std::inserter(result, result.end()));
142  return result;
143  }
144 
146  template <typename T>
148  std::sort(s1.begin(), s1.end()); // set_union expects sorted things
149  std::sort(s2.begin(), s2.end()); // set_union expects sorted things
150 
151  std::set<T> result;
152  std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
153  std::inserter(result, result.end()));
154  return result;
155  }
156 
158  template <typename T>
159  std::set<T> set_union(std::set<T> s1, emp::vector<T> s2) {
160  std::sort(s2.begin(), s2.end()); // set_union expects sorted things
161 
162  std::set<T> result;
163  std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
164  std::inserter(result, result.end()));
165  return result;
166  }
167 
169  template <typename T>
170  std::set<T> set_union(emp::vector<T> s1, std::set<T> s2) {
171  std::sort(s1.begin(), s1.end()); // set_union expects sorted things
172 
173  std::set<T> result;
174  std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
175  std::inserter(result, result.end()));
176  return result;
177  }
178 
180  template <typename T>
181  std::set<T> symmetric_difference(std::set<T> s1, std::set<T> s2) {
182  std::set<T> result;
183  std::set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
184  std::inserter(result, result.end()));
185  return result;
186  }
187 
189  template <typename T>
191  std::sort(s1.begin(), s1.end()); // set_symmetric_difference expects sorted things
192  std::sort(s2.begin(), s2.end()); // set_symmetric_difference expects sorted things
193 
194  std::set<T> result;
195  std::set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
196  std::inserter(result, result.end()));
197  return result;
198  }
199 
201  template <typename T>
202  std::set<T> symmetric_difference(std::set<T> s1, emp::vector<T> s2) {
203  std::sort(s2.begin(), s2.end()); // set_symmetric_difference expects sorted things
204 
205  std::set<T> result;
206  std::set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
207  std::inserter(result, result.end()));
208  return result;
209  }
210 
212  template <typename T>
213  std::set<T> symmetric_difference(emp::vector<T> s1, std::set<T> s2) {
214  std::sort(s1.begin(), s1.end()); // set_symmetric_difference expects sorted things
215 
216  std::set<T> result;
217  std::set_symmetric_difference(s1.begin(), s1.end(), s2.begin(), s2.end(),
218  std::inserter(result, result.end()));
219  return result;
220  }
221 
222 
223 }
224 
225 #endif
std::set< T > intersection(std::set< T > s1, std::set< T > s2)
Compute the set intersection of.
Definition: set_utils.h:95
iterator end() noexcept
Definition: vector.h:155
std::set< T > set_union(emp::vector< T > s1, std::set< T > s2)
Compute the set union of.
Definition: set_utils.h:170
std::set< T > set_union(std::set< T > s1, std::set< T > s2)
Compute the set union of.
Definition: set_utils.h:138
bool Has(const MAP_T &in_map, const KEY_T &key)
Take any map type, and run find to determine if a key is present.
Definition: map_utils.h:21
void insert(std::set< T > &s1, const std::set< T > &s2)
Insert the full contents of s2 into s1.
Definition: set_utils.h:24
iterator begin() noexcept
Definition: vector.h:153
If we are in emscripten, make sure to include the header.
Definition: array.h:37
std::set< T > difference(std::set< T > &s1, std::set< T > &s2)
Compute the set difference of.
Definition: set_utils.h:50
std::set< T > symmetric_difference(std::set< T > s1, std::set< T > s2)
Compute the set symmetric_difference of.
Definition: set_utils.h:181
typename internal::ip_sort< T >::result sort
Definition: IntPack.h:193