Question

Possible Duplicate:
C#. Need to optimise counting positive and negative values

I need to maximize speed of the following functionality:

• a. a value comes in. value has 2 properties – int value and long timestamp in ticks.
• b. need to count previously stored values which are younger than 1ms (from the current).
• c. need to count negative and positive separately.
• d. i only need to know if there are either 10 neg or pos values. i dont need to keep any other knowledge of the values.

me thinks – to implement 2 ring arrays for pos and neg separately, replacing expired with 0 keeping track of pos.neg counts as they come.

any thoughts?

Answer 1

Maintaining 2 buffers to keep the positives separated from the negatives sounds like a pain and inefficient.

You could instead have a single buffer with all the values, and use std::accumulate to count up the positives and negatives. If you start with a collection of all the tuples (each of which has an age and a value), you could begin by sorting the collection according to age, finding the last element that is <= 1 ms old, and then using accumulate from begin() to that point. Here’s some code that demonstrates that last bit:

#include <algorithm>
#include <numeric>
#include <iterator>
#include <vector>
#include <string>
#include <ctime>
using namespace std;

struct Counter 
{
    Counter(unsigned pos=0, unsigned neg=0) : pos_(pos), neg_(neg) {};
    unsigned pos_, neg_;
    Counter& operator+(int n)
    {
        if( n < 0 )
            ++neg_;
        else if( n > 0 )
            ++pos_;
        return * this;
    }
};

int main()
{
    srand((unsigned)time(0));

    vector<int> vals;
    generate_n(back_inserter(vals), 1000, []() 
    {
        return (rand() / (RAND_MAX/40)) - 20;
    });

    Counter cnt = accumulate(vals.begin(), vals.end(), Counter());
}

If sorting the collection by age and then searching the sorted results for the last eligible entry sounds too ineficient, you could use for_each_if instead of accumulate and simply iterate over the whole collection once. for_each_if isn’t part of the Standard Library, but it’s easy enough to write. If you don’t want to muck about with writing your own for_each_if that’s fine, too. You could simply tweak the accumulator a bit so that it doesn’t accumulate elements which are too old:

#include <algorithm>

#include <numeric>
#include <iterator>
#include <vector>
#include <string>
#include <ctime>
using namespace std;

struct Tuple
{
    int val_;
    unsigned age_;
};

struct Counter 
{
    Counter(unsigned pos=0, unsigned neg=0) : pos_(pos), neg_(neg) {};
    unsigned pos_, neg_;
    Counter& operator+(const Tuple& tuple)
    {
        if( tuple.age_ > 1 )
            return * this; 

        if( tuple.val_ < 0 )
            ++neg_;
        else if( tuple.val_ > 0 )
            ++pos_;

        return * this;
    }
};

int main()
{
    srand((unsigned)time(0));

    vector<Tuple> tuples;
    generate_n(back_inserter(tuples), 1000, []() -> Tuple
    {
        Tuple retval;
        retval.val_ = (rand() / (RAND_MAX/40)) - 20;
        retval.age_ = (rand() / (RAND_MAX/5));
        return retval;
    });

    Counter cnt = accumulate(tuples.begin(), tuples.end(), Counter());
}