Boost logo

Boost :

From: Jeremy Siek (jsiek_at_[hidden])
Date: 2001-03-27 14:00:20


Ahh, a wonderful application for the iterator_adaptor library... the below
code would be much shorter :)

This also motivates something that needs to be added (as the VTL folks
have mentioned): an adaptor that combines two iterators into one.

Cheers,
Jeremy

On 27 Mar 2001 nbecker_at_[hidden] wrote:

nbecke> In the field of signal processing it is often necessary to interface
nbecke> between algorithms that expect complex vs. scalar vectors as
nbecke> arguments. To prevent unnecessary copying it is nice to use iterator
nbecke> adaptors to interface between them.
nbecke>
nbecke> Here is my own primitive attempt. Perhaps someone can improve on it:
nbecke>
nbecke> ComplexAdapt.H
nbecke>
nbecke> #ifndef ComplexAdapt_H
nbecke> #define ComplexAdapt_H
nbecke>
nbecke> #include <complex>
nbecke> #include <cstddef>
nbecke> #include <stdexcept>
nbecke>
nbecke> template<class T, class ComplexIterator>
nbecke> class ComplexToRealAdapt {
nbecke> private:
nbecke> ComplexIterator I;
nbecke> public:
nbecke> typedef T value_type;
nbecke> typedef ComplexToRealAdapt self;
nbecke> typedef ptrdiff_t difference_type;
nbecke> typedef size_t size_type;
nbecke> typedef iterator_traits<ComplexIterator>::iterator_category iterator_category;
nbecke> typedef T* pointer;
nbecke> typedef T& reference;
nbecke>
nbecke> //! STL wants this
nbecke> ComplexToRealAdapt () {}
nbecke>
nbecke> ComplexToRealAdapt (ComplexIterator C) :
nbecke> I (C)
nbecke> {}
nbecke>
nbecke> value_type operator*() const {
nbecke> return real (*I);
nbecke> }
nbecke>
nbecke> self& operator++ () {
nbecke> I++;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator++ (int) {
nbecke> self tmp = *this;
nbecke> ++*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator-- () {
nbecke> I--;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator-- (int) {
nbecke> self tmp = *this;
nbecke> --*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator+=(difference_type n) {
nbecke> I += n;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self& operator-=(difference_type n) { return *this += -n; }
nbecke>
nbecke> self operator+(difference_type n) const {
nbecke> self tmp = *this;
nbecke> return tmp += n;
nbecke> }
nbecke>
nbecke> value_type operator[](difference_type n) const { return *(*this + n); }
nbecke>
nbecke> bool operator==(const self& x) const { return I == x.I; }
nbecke>
nbecke> bool operator!=(const self& x) const { return !(*this == x); }
nbecke>
nbecke> difference_type operator- (const self& x) const {
nbecke> return I - x.I;
nbecke> }
nbecke>
nbecke> };
nbecke>
nbecke> template<class T, class ComplexIterator>
nbecke> class ComplexToImagAdapt {
nbecke> private:
nbecke> ComplexIterator I;
nbecke> public:
nbecke> typedef T value_type;
nbecke> typedef ComplexToImagAdapt self;
nbecke> typedef ptrdiff_t difference_type;
nbecke> typedef size_t size_type;
nbecke> typedef iterator_traits<ComplexIterator>::iterator_category iterator_category;
nbecke> typedef T* pointer;
nbecke> typedef T& reference;
nbecke>
nbecke> ComplexToImagAdapt (ComplexIterator C) :
nbecke> I (C)
nbecke> {}
nbecke>
nbecke> value_type operator*() const {
nbecke> return imag (*I);
nbecke> }
nbecke>
nbecke> self& operator++ () {
nbecke> I++;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator++ (int) {
nbecke> self tmp = *this;
nbecke> ++*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator-- () {
nbecke> I--;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator-- (int) {
nbecke> self tmp = *this;
nbecke> --*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator+=(difference_type n) {
nbecke> I += n;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self& operator-=(difference_type n) { return *this += -n; }
nbecke>
nbecke> self operator+(difference_type n) const {
nbecke> self tmp = *this;
nbecke> return tmp += n;
nbecke> }
nbecke>
nbecke> value_type operator[](difference_type n) const { return *(*this + n); }
nbecke>
nbecke> bool operator==(const self& x) const { return I == x.I; }
nbecke>
nbecke> bool operator!=(const self& x) const { return !(*this == x); }
nbecke>
nbecke> difference_type operator- (const self& x) const {
nbecke> return I - x.I;
nbecke> }
nbecke>
nbecke> };
nbecke>
nbecke> template<class T, class RealIterator, class ImagIterator>
nbecke> class RealToComplexAdapt {
nbecke> private:
nbecke> RealIterator rI;
nbecke> ImagIterator iI;
nbecke> public:
nbecke> typedef complex<T> value_type;
nbecke> typedef RealToComplexAdapt self;
nbecke> typedef ptrdiff_t difference_type;
nbecke> typedef size_t size_type;
nbecke> // I guess we just have to pick one
nbecke> typedef iterator_traits<RealIterator>::iterator_category iterator_category;
nbecke> typedef const complex<T>* pointer;
nbecke> typedef const complex<T>& reference;
nbecke>
nbecke> RealToComplexAdapt (RealIterator _rI, ImagIterator _iI) :
nbecke> rI (_rI),
nbecke> iI (_iI)
nbecke> {}
nbecke>
nbecke> value_type operator*() const {
nbecke> return complex<T> (*rI, *iI);
nbecke> }
nbecke>
nbecke> self& operator++() {
nbecke> rI++;
nbecke> iI++;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator++ (int) {
nbecke> self tmp = *this;
nbecke> ++*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator-- () {
nbecke> rI--;
nbecke> iI--;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self operator-- (int) {
nbecke> self tmp = *this;
nbecke> --*this;
nbecke> return tmp;
nbecke> }
nbecke>
nbecke> self& operator+=(difference_type n) {
nbecke> rI += n;
nbecke> iI += n;
nbecke> return *this;
nbecke> }
nbecke>
nbecke> self& operator-=(difference_type n) { return *this += -n; }
nbecke>
nbecke> self operator+(difference_type n) const {
nbecke> self tmp = *this;
nbecke> return tmp += n;
nbecke> }
nbecke>
nbecke> value_type operator[](difference_type n) const { return *(*this + n); }
nbecke>
nbecke> bool operator==(const self& x) const { return rI == x.rI && iI == x.iI; }
nbecke>
nbecke> bool operator!=(const self& x) const { return !(*this == x); }
nbecke>
nbecke> difference_type operator- (const self& x) const {
nbecke> if (iI - x.iI != rI - x.rI)
nbecke> throw invalid_argument ("RealToComplexAdapt");
nbecke> return iI - x.iI;
nbecke> }
nbecke>
nbecke> };
nbecke>
nbecke>
nbecke> #endif
nbecke>
nbecke> To unsubscribe, send email to: <mailto:boost-unsubscribe_at_[hidden]>
nbecke>
nbecke>
nbecke> Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
nbecke>
nbecke>
nbecke>

----------------------------------------------------------------------
 Jeremy Siek www: http://www.lsc.nd.edu/~jsiek/
 Ph.D. Candidate email: jsiek_at_[hidden]
 Univ. of Notre Dame work phone: (219) 631-3906
----------------------------------------------------------------------


Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk