Rheolef  7.1
an efficient C++ finite element environment
index_set_body.icc
Go to the documentation of this file.
1 #ifndef _RHEOLEF_INDEX_SET_BODY_ICC
2 #define _RHEOLEF_INDEX_SET_BODY_ICC
23 //
24 // this code is shared by:
25 // - index_set.h (with extension to serialization & mpi)
26 // - bamg2geo.cc
27 // - msh2geo.cc
28 // => avoid code redundancy
29 //
30 
31 #include <limits>
32 
33 namespace rheolef {
34 
36  : base()
37 {
38  for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
39  base::insert (*iter);
40  }
41 }
42 index_set&
44 {
45  base::clear();
46  for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
47  base::insert (*iter);
48  }
49  return *this;
50 }
51 index_set&
53 {
54  for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
55  base::insert (*iter);
56  }
57  return *this;
58 }
59 std::istream&
60 operator>> (std::istream& is, index_set& x)
61 {
63  size_type n;
64  is >> n;
65  x.clear();
66  for (size_type i = 0; i < n; i++) {
67  size_type xi;
68  is >> xi;
69  x.insert (xi);
70  }
71  return is;
72 }
73 std::ostream&
74 operator<< (std::ostream& os, const index_set& x)
75 {
77  os << x.base::size() << "\t";
78  for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
79  os << " " << *iter;
80  }
81  return os;
82 }
83 // c := a union b
84 void
85 set_union (const index_set& a, const index_set& b, index_set& c)
86 {
87  c.erase(c.begin(), c.end());
88  std::set_union (a.begin(), a.end(), b.begin(), b.end(), std::inserter((index_set::base&)c, c.end()));
89 }
90 // c := a inter b
91 void
93 {
94  c.erase(c.begin(), c.end());
95  std::set_intersection (a.begin(), a.end(), b.begin(), b.end(), std::inserter((index_set::base&)c, c.end()));
96 }
97 // a := a union b
98 void
100 {
101  const size_type infty = std::numeric_limits<size_type>::max();
102  iterator iter_a = begin();
103  iterator last_a = end();
104  const_iterator iter_b = b.begin();
105  const_iterator last_b = b.end();
106  while (iter_a != last_a || iter_b != last_b) {
107  if (iter_b == last_b) return;
108  if (iter_a == last_a) {
109  base::insert(iter_b,last_b);
110  return;
111  }
112  size_type ia = (*iter_a);
113  size_type ib = (*iter_b);
114  if (ia == ib) {
115  iter_a++;
116  iter_b++;
117  } else if (ia < ib) {
118  iter_a++;
119  } else { // ib < ia
120  // Set has the important property that inserting a new element
121  // into a set does not invalidate iterators that point to existing elements.
122  insert(ib);
123  iter_b++;
124  }
125  }
126 }
127 // a := a union b
128 void
130 {
131  const size_type infty = std::numeric_limits<size_type>::max();
132  iterator iter_a = begin();
133  iterator last_a = end();
134  const_iterator iter_b = b.begin();
135  const_iterator last_b = b.end();
136  while (iter_a != last_a || iter_b != last_b) {
137  if (iter_a == last_a) return;
138  if (iter_b == last_b) { // last_b is reached
139  base::erase(iter_a, last_a);
140  return;
141  }
142  size_type ia = (*iter_a);
143  size_type ib = (*iter_b);
144  if (ia == ib) {
145  iter_a++;
146  iter_b++;
147  } else if (ia < ib) {
148  // Erasing an element from a set also does not invalidate any iterators, except,
149  // of course, for iterators that actually point to the element that is being erased.
150  iterator curr_a = iter_a++;
151  base::erase(curr_a);
152  } else { // ib < ia
153  iter_b++;
154  }
155  }
156 }
157 
158 } // namepace rheolef
159 #endif // _RHEOLEF_INDEX_SET_BODY_ICC
std::set< std::size_t > base
void inplace_intersection(const index_set &b)
void inplace_union(const index_set &b)
void insert(size_type dis_i)
index_set & operator=(const index_set &x)
index_set & operator+=(size_type dis_i)
size_t size_type
Definition: basis_get.cc:76
This file is part of Rheolef.
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
void set_intersection(const index_set &a, const index_set &b, index_set &c)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
void set_union(const index_set &a, const index_set &b, index_set &c)