You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
sequence.hh
Go to the documentation of this file.
1
8#ifndef sequence_hh
9#define sequence_hh
10
11#include <vector>
12#include <algorithm>
13#include <set>
14#include <queue>
15#include <stdarg.h>
16#include <initializer_list>
17#include "basics/typedefs.hh"
18#include "basics/outputOperator.hh"
19#include "basics/exceptions.hh"
20#include "basics/pointerOutput.hh"
21
22#define SeqInput_D 0
23
24namespace concepts {
25
26 // forward declaration
27 template<class F>
28 class BaseSequence;
29
30 // ************************************************************** Sequence **
31
38 template<class F>
39 class Sequence : public BaseSequence<F> {
40 public:
41 Sequence() : BaseSequence<F>() {}
42 Sequence(const int N) : BaseSequence<F>(N) {}
43 template<class G>
44 Sequence(const G& seq) : BaseSequence<F>(seq) {}
45 virtual ~Sequence() {}
46 };
47
48 template<>
49 class Sequence<bool>;
50
51
52 // *********************************************************** BaseSequence **
53
58 template<class F>
59 class BaseSequence : public std::vector<F>, public concepts::OutputOperator {
60 public:
61 BaseSequence() : std::vector<F>() {}
67 BaseSequence(const std::string& str);
68
70 BaseSequence(std::queue<F> q);
71
73 BaseSequence(const int N);
74
76 template<class G>
77 BaseSequence(const G& seq)
78 : std::vector<F>(seq) {}
79 virtual ~BaseSequence() {}
80
81
83 inline operator Sequence<F>() const { return *this; }
84
85 inline operator std::set<F>() const {
86 std::set<F> set;
87 for(typename std::vector<F>::
88 const_iterator i = this->begin(); i != this->end(); ++i)
89 set.insert(*i);
90 return set;
91 }
92
96 template<class G, class H>
97 inline Sequence<G> operator()(G (H::*fun)() const) const;
101 template<class G, class H>
102 inline Sequence<G*> operator()(G& (H::*fun)() const) const;
106 template<class G, class H, class I, class J>
107 inline Sequence<G> operator()(G (H::*fun)(I) const, J i) const;
108
109 // Return set union
110 inline std::vector<bool> operator||(const Sequence<F>& set) const;
111 // Return set intersection
112 inline std::vector<bool> operator&&(const Sequence<F>& set) const;
113
114
115 // Return a sequence with appended \c seq
116 inline Sequence<F> operator+(const Sequence<F>& seq) const;
117 // Return sequence, where \c val is not inside
118 inline Sequence<F> operator-(const F& val) const;
119 // Return sequence, where are elements of \c seq are not inside
120 inline Sequence<F> operator-(const Sequence<F>& seq) const;
122 inline std::vector<bool> operator==(const F val) const;
124 inline Sequence<F> operator()(const BaseSequence<bool>& seq) const;
125
127 inline bool exist(F val) const;
128 protected:
129 virtual std::ostream& info(std::ostream& os) const;
130 };
131
132 template<class F>
133 std::istream& operator>>(std::istream& is, BaseSequence<F>& seq) {
134 F val;
135 while(!is.eof()) {
136 is >> val;
137 DEBUGL(SeqInput_D, "val = " << val);
138 if (!is.fail())
139 seq.push_back(val);
140 }
141 return is;
142 }
143
144 template<class F>
145 BaseSequence<F>::BaseSequence(const std::string& str) {
146 if (str.size() > 0) {
147 std::stringstream s;
148 s << str;
149 s >> *this;
150 }
151 }
152
153 template<class F>
154 BaseSequence<F>::BaseSequence(std::queue<F> q) {
155 while(!q.empty()) {
156 // take the first element of the queue
157 this->push_back(q.front());
158 // delete the first element
159 q.pop();
160 }
161 }
162
163
164 template<class F>
165 BaseSequence<F>::BaseSequence(const int N)
166 {
167 this->resize(N);
168 }
169
170 // e.g. concepts::Key::key()
171 template<class F>
172 template<class G, class H>
173 Sequence<G> BaseSequence<F>::operator()(G (H::*fun)() const) const {
174 std::vector<G> seq;
175 for(typename std::vector<F>::
176 const_iterator i = this->begin(); i != this->end(); ++i) {
177 G val = ((*i)->*fun)();
178 seq.push_back(val);
179 }
180 return seq;
181 }
182 // e.g. concepts::Connector1::key()
183 template<class F>
184 template<class G, class H>
185 Sequence<G*> BaseSequence<F>::operator()(G& (H::*fun)() const) const {
186 std::vector<G*> seq;
187 for(typename std::vector<F>::
188 const_iterator i = this->begin(); i != this->end();++i) {
189 G* val = &((*i)->*fun)();
190 seq.push_back(val);
191 }
192 return seq;
193 }
194 // e.g. concepts::Connector1::vertex(uint i)
195 template<class F>
196 template<class G, class H, class I, class J>
197 Sequence<G> BaseSequence<F>::operator()(G (H::*fun)(I) const, J i) const {
198 std::vector<G> seq;
199 for(typename std::vector<F>::
200 const_iterator is = this->begin(); is != this->end();++is) {
201 G val = ((*is)->*fun)(i);
202 seq.push_back(val);
203 }
204 return seq;
205 }
206
207 template<class F>
208 std::vector<bool> BaseSequence<F>::operator||(const Sequence<F>& seq) const
209 {
210 conceptsAssert(this->size() == seq.size(), Assertion());
211 std::vector<bool> result(this->size(), false);
212
213 std::vector<bool>::iterator i = result.begin();
214 typename std::vector<F>::
215 const_iterator it = this->begin(), is = seq.begin();
216 for(; it != this->end(); ++it, ++is, ++i)
217 *i = *it || *is;
218 return result;
219 }
220
221 template<class F>
222 std::vector<bool> BaseSequence<F>::operator&&(const Sequence<F>& seq) const
223 {
224 conceptsAssert(this->size() == seq.size(), Assertion());
225 std::vector<bool> result(this->size(), false);
226
227 std::vector<bool>::iterator i = result.begin();
228 typename std::vector<F>::
229 const_iterator it = this->begin(), is = seq.begin();
230 for(; it != this->end(); ++it, ++is, ++i)
231 *i = *it && *is;
232 return result;
233 }
234
235 template<class F>
236 Sequence<F> BaseSequence<F>::operator-(const Sequence<F>& seq) const {
237 std::set<F> set = seq;
238 std::vector<F> result;
239 result.reserve(this->size());
240 for(typename std::vector<F>::
241 const_iterator i = this->begin(); i != this->end(); ++i)
242 if (set.find(*i) == set.end()) result.push_back(*i);
243 return result;
244 }
245
246 template<class F>
247 Sequence<F> BaseSequence<F>::operator-(const F& val) const {
248 std::vector<F> result;
249 result.reserve(this->size());
250 for(typename std::vector<F>::
251 const_iterator i = this->begin(); i != this->end(); ++i)
252 if (!(*i == val)) result.push_back(*i);
253 return result;
254 }
255
256 template<class F>
257 Sequence<F> BaseSequence<F>::operator+(const Sequence<F>& seq) const {
258 std::vector<F> result(this->size() + seq.size());
259 typename std::vector<F>::iterator i = result.begin();
260 typename std::vector<F>::
261 const_iterator it = this->begin(), is = seq.begin();
262 for(; it != this->end(); ++it, ++i) *i = *it;
263 for(; is != seq.end(); ++is, ++i) *i = *is;
264 return result;
265 }
266
267 template<class F>
268 std::vector<bool> BaseSequence<F>::operator==(const F val) const {
269 std::vector<bool> result(this->size());
270// uint i = 0;
271// for(typename std::vector<F>::
272// const_iterator is = this->begin(); is != this->end(); ++is, ++i)
273// if (*is == val) result.push_back(i);
274 std::vector<bool>::iterator i = result.begin();
275 for(typename std::vector<F>::
276 const_iterator it = this->begin(); it != this->end(); ++it, ++i)
277 *i = *it == val;
278 return result;
279 }
280
281// template<class F>
282// Sequence<F> BaseSequence<F>::operator()(const Sequence<uint>& seq) const {
283// std::vector<F> result(seq.size());
284// std::vector<uint> sortedIdx = seq;
285// sort(sortedIdx.begin(), sortedIdx.end());
286// sortedIdx.erase(unique(sortedIdx.begin(), sortedIdx.end()),
287// sortedIdx.end());
288
289// uint i = 0;
290// std::vector<uint>::const_iterator is = sortedIdx.begin();
291// typename std::vector<F>::const_iterator it = this->begin();
292// typename std::vector<F>::iterator ir = result.begin();
293// while(is != sortedIdx.end() && it != this->end()) {
294// if (i == *is) {
295// *ir = *it;
296// ++ir;
297// ++is;
298// }
299// ++it; ++i;
300// }
301// conceptsAssert(is == sortedIdx.end(), Assertion());
302// return result;
303// }
304
305 template<class F>
306 Sequence<F> BaseSequence<F>::operator()(const BaseSequence<bool>& seq) const {
307 conceptsAssert(this->size() == seq.size(), Assertion());
308
309 std::vector<F> result(count(seq.begin(), seq.end(), true));
310 if (result.size() > 0) {
311 std::vector<bool>::const_iterator is = seq.begin();
312 typename std::vector<F>::const_iterator it = this->begin();
313 typename std::vector<F>::iterator i = result.begin();
314 for(; it != this->end(); ++it, ++is)
315 if (*is) {
316 *i = *it;
317 ++i;
318 }
319 }
320 return result;
321 }
322
323 template<class F>
324 bool BaseSequence<F>::exist(F val) const {
325 for(typename std::vector<F>::
326 const_iterator i = this->begin(); i != this->end(); ++i)
327 {
328 if (*i == val) return true;
329 }
330 return false;
331 // return this->find(val) != this->end();
332 }
333
334 template<class F>
335 std::ostream& BaseSequence<F>::info(std::ostream& os) const {
336 os << concepts::typeOf(*this)<<"(";
337 for(typename std::vector<F>::
338 const_iterator i = this->begin(); i != this->end();) {
339 pointerOutput(os, *i);
340 if (++i != this->end()) os << ", ";
341 }
342 return os << ")";
343 }
344
345 // ******************************************************** Sequence<bool> **
346
347 template<>
348 class Sequence<bool> : public BaseSequence<bool> {
349 public:
351 Sequence() : BaseSequence<bool>() {}
353 template<class F>
354 Sequence(const F& seq) : BaseSequence<bool>(seq) {}
355 virtual ~Sequence() {}
356
358 Sequence<bool> operator&(const Sequence<bool>& seq) const;
360 Sequence<bool> operator|(const Sequence<bool>& seq) const;
362 Sequence<bool> operator~() const;
363 };
364
365 // ************************************************************ makeSequence **
366
374 template<class F>
375 Sequence<F> makeSequence(uint n, const F& first, ...) {
376 Sequence<F> data(n);
377 data[0] = first;
378
379 va_list param;
380 va_start(param, first);
381 for(uint i = 1; i < n; ++i)
382 data[i] = va_arg(param, F);
383 va_end(param);
384 return data;
385 }
386
394 template<class F>
395 Sequence<F> makeSequence(std::initializer_list<F> list) {
396 uint n = list.size();
397 Sequence<F> data(n);
398 uint idx = 0;
399 for( F elem : list )
400 data[idx++] = elem;
401 return data;
402 }
403
404 // ************************************************* makeEquidistantSequence **
405
406 template<class F>
407 Sequence<F> makeEquidistantSequence(uint n, const F& first, const F& diff)
408 {
409 Sequence<F> data(n);
410 typename Sequence<F>::iterator i = data.begin();
411 F current = *i++ = first;
412 for(; i != data.end(); ++i)
413 *i++ = (current+=diff);
414 return data;
415 }
416
417 // ****************************************************** makeRangeSequence **
418
420 Sequence<int> makeRangeSequence(uint n);
421
423 Sequence<int> makeRangeSequence(int start, int afterlast);
424
428 Sequence<int> makeRangeSequence(int start, int afterlast, uint dist);
429
430 // ******************************************** makeSignAlternatingSequence **
431
433 Sequence<int> makeSignAlternatingSequence(uint n);
434
435 // ************************************************************ operator*() **
436
437 template<class F, class G>
438 Sequence<typename Combtype<F,G>::type>
439 operator*(const Sequence<F> seq1, const Sequence<G> seq2)
440 {
441 conceptsAssert(seq1.size() == seq2.size(), Assertion());
442
443 Sequence<typename Combtype<F,G>::type> seq;
444 typename Sequence<F>::const_iterator i1 = seq1.begin();
445 typename Sequence<G>::const_iterator i2 = seq2.begin();
446 typename Combtype<F,G>::type prod;
447 for(; i1 != seq1.end(); ) {
448 prod = *i1++;
449 prod *= *i2++;
450 seq.push_back(prod);
451 }
452 return seq;
453 }
454
455 template<class F, class G>
456 Sequence<typename Combtype<F,G>::type>
457 operator*(const Sequence<F> seq1, const G factor)
458 {
459 Sequence<typename Combtype<F,G>::type> seq;
460 typename Sequence<F>::const_iterator i1 = seq1.begin();
461 for(; i1 != seq1.end(); )
462 seq.push_back( *i1++ * factor);
463 return seq;
464 }
465
466 // ************************************************************ operator/() **
467
468 template<class F, class G>
469 Sequence<typename Combtype<F,G>::type>
470 operator/(const Sequence<F> seq1, const Sequence<G> seq2)
471 {
472 conceptsAssert(seq1.size() == seq2.size(), Assertion());
473
474 Sequence<typename Combtype<F,G>::type> seq;
475 typename Sequence<F>::const_iterator i1 = seq1.begin();
476 typename Sequence<F>::const_iterator i2 = seq2.begin();
477 for(; i1 != seq1.end(); )
478 seq.push_back( *i1++ / *i2++);
479 return seq;
480 }
481
482 template<class F, class G>
483 Sequence<typename Combtype<F,G>::type>
484 operator/(const Sequence<F> seq1, const G divisor)
485 {
486 Sequence<typename Combtype<F,G>::type> seq;
487 typename Sequence<F>::const_iterator i1 = seq1.begin();
488 for(; i1 != seq1.end(); )
489 seq.push_back( *i1++ / divisor);
490 return seq;
491 }
492
493} // namespace concepts
494
495#endif // sequence_hh
concepts::BaseSequence::operator==
std::vector< bool > operator==(const F val) const
Returns true for the elements with are equal to val.
Definition sequence.hh:268
concepts::BaseSequence::operator()
Sequence< F > operator()(const BaseSequence< bool > &seq) const
Returns subsequence which indices are true in seq.
Definition sequence.hh:306
concepts::BaseSequence::operator()
Sequence< G * > operator()(G &(H::*fun)() const) const
Definition sequence.hh:185
concepts::BaseSequence::BaseSequence
BaseSequence(const std::string &str)
Definition sequence.hh:145
concepts::BaseSequence::BaseSequence
BaseSequence(const G &seq)
Constructor, which uses the constructor of the base class std::vector.
Definition sequence.hh:77
concepts::BaseSequence::BaseSequence
BaseSequence(const int N)
Constructor taking an integer.
Definition sequence.hh:165
concepts::BaseSequence::exist
bool exist(F val) const
Returns true, if a value is in the seq.
Definition sequence.hh:324
concepts::BaseSequence::operator()
Sequence< G > operator()(G(H::*fun)(I) const, J i) const
Definition sequence.hh:197
concepts::BaseSequence::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition sequence.hh:335
concepts::BaseSequence::operator()
Sequence< G > operator()(G(H::*fun)() const) const
Definition sequence.hh:173
concepts::BaseSequence::BaseSequence
BaseSequence(std::queue< F > q)
Constructor taking a queue (takes a copy)
Definition sequence.hh:154
concepts::Sequence< bool >::operator&
Sequence< bool > operator&(const Sequence< bool > &seq) const
Deletes each bit, which is not set in \seq.
concepts::Sequence< bool >::Sequence
Sequence()
Standard Constructor.
Definition sequence.hh:351
concepts::Sequence< bool >::Sequence
Sequence(const F &seq)
Constructor, which uses the constructor of the base class BaseSequence.
Definition sequence.hh:354
concepts::Sequence< bool >::operator|
Sequence< bool > operator|(const Sequence< bool > &seq) const
Set each bit, which is set in \seq.
concepts::Sequence< bool >::operator~
Sequence< bool > operator~() const
Returns copy of this sequence with negate bits.
conceptsAssert
#define conceptsAssert(cond, exc)
Definition exceptions.hh:394
DEBUGL
#define DEBUGL(doit, msg)
Definition debug.hh:40
concepts::typeOf
std::string typeOf(const T &t)
Definition output.hh:43
concepts::makeRangeSequence
Sequence< int > makeRangeSequence(uint n)
Returns the sequence 0,1,...,n-1.
concepts::makeSignAlternatingSequence
Sequence< int > makeSignAlternatingSequence(uint n)
Returns the sequence +1,-1, +1,...
concepts::makeSet
Set< F > makeSet(uint n, const F &first,...)
Definition set.hh:320
concepts::makeSequence
Sequence< F > makeSequence(uint n, const F &first,...)
Definition sequence.hh:375
Generated on Wed Sep 13 2023 21:06:24 for Concepts by doxygen 1.9.8