Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
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//
30namespace rheolef {
31
33 : base()
34{
35 for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
36 base::insert (*iter);
37 }
38}
41{
42 base::clear();
43 for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
44 base::insert (*iter);
45 }
46 return *this;
47}
50{
51 for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
52 base::insert (*iter);
53 }
54 return *this;
55}
56std::istream&
57operator>> (std::istream& is, index_set& x)
58{
60 size_type n;
61 is >> n;
62 x.clear();
63 for (size_type i = 0; i < n; i++) {
64 size_type xi;
65 is >> xi;
66 x.insert (xi);
67 }
68 return is;
69}
70std::ostream&
71operator<< (std::ostream& os, const index_set& x)
72{
74 os << x.base::size() << "\t";
75 for (std::set<size_type>::const_iterator iter = x.base::begin(), last = x.base::end(); iter != last; iter++) {
76 os << " " << *iter;
77 }
78 return os;
79}
80// c := a union b
81void
82set_union (const index_set& a, const index_set& b, index_set& c)
83{
84 c.erase(c.begin(), c.end());
85 std::set_union (a.begin(), a.end(), b.begin(), b.end(), std::inserter((index_set::base&)c, c.end()));
86}
87// c := a inter b
88void
90{
91 c.erase(c.begin(), c.end());
92 std::set_intersection (a.begin(), a.end(), b.begin(), b.end(), std::inserter((index_set::base&)c, c.end()));
93}
94// a := a union b
95void
97{
98 const size_type infty = std::numeric_limits<size_type>::max();
99 iterator iter_a = begin();
100 iterator last_a = end();
101 const_iterator iter_b = b.begin();
102 const_iterator last_b = b.end();
103 while (iter_a != last_a || iter_b != last_b) {
104 if (iter_b == last_b) return;
105 if (iter_a == last_a) {
106 base::insert(iter_b,last_b);
107 return;
108 }
109 size_type ia = (*iter_a);
110 size_type ib = (*iter_b);
111 if (ia == ib) {
112 iter_a++;
113 iter_b++;
114 } else if (ia < ib) {
115 iter_a++;
116 } else { // ib < ia
117 // Set has the important property that inserting a new element
118 // into a set does not invalidate iterators that point to existing elements.
119 insert(ib);
120 iter_b++;
121 }
122 }
123}
124// a := a union b
125void
127{
128 const size_type infty = std::numeric_limits<size_type>::max();
129 iterator iter_a = begin();
130 iterator last_a = end();
131 const_iterator iter_b = b.begin();
132 const_iterator last_b = b.end();
133 while (iter_a != last_a || iter_b != last_b) {
134 if (iter_a == last_a) return;
135 if (iter_b == last_b) { // last_b is reached
136 base::erase(iter_a, last_a);
137 return;
138 }
139 size_type ia = (*iter_a);
140 size_type ib = (*iter_b);
141 if (ia == ib) {
142 iter_a++;
143 iter_b++;
144 } else if (ia < ib) {
145 // Erasing an element from a set also does not invalidate any iterators, except,
146 // of course, for iterators that actually point to the element that is being erased.
147 iterator curr_a = iter_a++;
148 base::erase(curr_a);
149 } else { // ib < ia
150 iter_b++;
151 }
152 }
153}
154
155} // namepace rheolef
156#endif // _RHEOLEF_INDEX_SET_BODY_ICC
field::size_type size_type
Definition branch.cc:430
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)
This file is part of Rheolef.
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
void set_intersection(const index_set &a, const index_set &b, index_set &c)
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
void set_union(const index_set &a, const index_set &b, index_set &c)