Re: Non-container Iterators
"Leslie Sanford" <jabberdabber@bitemehotmail.com> wrote:
My area of programming is DSP. I write things like filters, oscillators,
envelopes, etc. I've been looking at STL iterators, and what's struck me is
that if I can find ways to model my code using STL's iterator conventions, I
could possibly make my code more economic while probably losing little to no
efficiency.
Then you might find this interesting:
class fibonacci: public std::iterator< std::forward_iterator_tag, int >
{
int prev_value, value, max;
public:
fibonacci(): prev_value(0), value(0), max(0) { }
explicit fibonacci(int m): prev_value(0), value(1), max(m) { }
const int operator*() const { return value; }
fibonacci& operator++() {
int tmp = value;
value += prev_value;
prev_value = tmp;
return *this;
}
fibonacci operator++(int) {
fibonacci tmp(*this);
++(*this);
return tmp;
}
friend bool operator==(const fibonacci& lhs, const fibonacci& rhs) {
bool result = false;
if ( lhs.value == 0 && rhs.value == 0 ) result = true;
else if ( rhs.value == 0 && !( lhs.value < lhs.max ) )
result = true;
else if ( lhs.value == 0 && !( rhs.value < rhs.max ) )
result = true;
else if ( lhs.prev_value == rhs.prev_value &&
lhs.value == rhs.value &&
lhs.max == rhs.max )
result = true;
return result;
}
};
bool operator!=(const fibonacci& lhs, const fibonacci& rhs) {
return !(lhs == rhs);
}
int main() {
copy( fibonacci( 20 ), fibonacci(),
ostream_iterator<int>( cout, " " ) );
cout << '\n';
}
As an example, an oscillator will have a "phase accumulator." So typically
in a loop I will have something like this:
phaseAccumulator += phaseIncrement;
if(phaseAccumulator >= 1.0f)
{
phaseAccumulator -= 1.0f;
}
output = waveform(phaseAccumulator);
It occurred to me that I could have a phase accumulator iterator. My code
would turn into this:
phaseAccumulator++;
output = waveform(*phaseAccumulator);
Much more compact. Or even better:
std::transform(phaseFirst, phaseLast, outputBuffer, SineWaveform());
Down to just one line of code. Ok, so far, so good. But there is a gray area
I'm concerned about.
I need to keep track of the phase. The phase is state that needs to persist
across iterations. This means that I need to give the iterator a pointer to
the phase variable when I create it so that as it's iterating, it's also
modifying the phase variable. Something like:
// Inside my Oscillator class somewhere:
it = PhaseIterator it(&phase, increment);
// Inside the PhaseIterator class:
PhaseIterator &operator++()
{
*phase += increment;
if(phase >= 1.0f)
{
phase -= 1.0f;
}
return *this;
}
This works, but it means that I can only use one phase iterator at a time.
Not if you put 'phase' inside the iterator. Then you can give two
iterators the same phase and increment and advance each of them a
different amount, and they will each be at a different spot in the
"container".
The key is to provide a sentinel iterator. In your case, the sentinel
can be a PhaseIterator that has an increment of 0.
class PhaseIterator : public std::iterator< std::forward_iterator_tag,
int >
{
float phase;
float increment;
int step;
int max;
public:
PhaseIterator(): phase(0), increment(0), step(0), max(0) { }
explicit PhaseIterator(float i, int m):
phase(0), increment(i), step(0), max(m) { }
const float operator*() const { return phase; }
PhaseIterator& operator++() {
phase += increment;
if ( phase >= 1.0f )
phase -= 1.0f;
++step;
return *this;
}
PhaseIterator operator++(int) {
PhaseIterator tmp(*this);
++(*this);
return tmp;
}
friend bool operator==(const PhaseIterator& lhs,
const PhaseIterator& rhs) {
bool result = false;
if ( lhs.phase == rhs.phase && lhs.increment == rhs.increment )
result = true;
else if ( rhs.increment == 0 && !( lhs.step < lhs.max ) )
result = true;
else if ( lhs.increment == 0 && !( rhs.step < rhs.max ) )
result = true;
return result;
}
};
bool operator!=(const PhaseIterator& lhs, const PhaseIterator& rhs) {
return !(lhs == rhs);
}
int main() {
copy( PhaseIterator( 0.07, 20 ), PhaseIterator(),
ostream_iterator<float>( cout, " " ) );
cout << '\n';
}