accumulate variant

Hello,
could anyone explain me how do this below? I need to return the number of elements summed in way to do the mean. Is there anybody, please?

Code:

---

class Value {   
      public:
          double _value;
          bool _missed;
              bool getMissed() const { return _missed; }
              //other methods....
      };
      class Other {
          vector<Value> _values;
          static double sum_values(const double& accum, const Value& right) {
           if ( right.getMissed() ) return accum;
           return accum + right._value;
          }
          void computeMean() {
                double mean = std::accumulate( _values.begin(), _values.end(), 0.0,   
                Other::sum_values );
          }
      };

---

The code is basically correct (assuming that's just part of it).
(If it is supposed to be complete: Other is all private, the constructors are missing etc.)


When I add that missing stuff (hint: do not forget to initialize _missed) the variable mean is assigned a meaningful value (namely the sum of my Values).

What is the problem you're having?

I need sum all "valid" values (exactly what it do) BUT I need to compute the "MEAN"; so I need to know how many "values" I've summed; how know how many they?

ok... you can do that by either:
* counting those not _missed (and thus iterating twice over your vector)
* or, by using a function object that counts both values and missed
(* or you could use globals, which is very bad imho)

try to replace your function by

Code:

---

class MeanAccumulator
{
	int counted_;
	double sum_;
public:
	MeanAccumulator() : counted_(0), sum_(0) {}
	void operator() (const Value &right)
        {
            if ( right.getMissed() ) return;
            ++counted_;
            sum_ += right._value;
         }
		double mean() const {return counted_ ? sum_/counted_ : 0; }
};
 
void computeMean() {
    MeanAccumulator res = std::for_each( _values.begin(), _values.end(),
                                         MeanAccumulator());
    std::cerr << "sum="<<res.mean()<<std::endl;
}

---

Note that the function object passed into for_each does NOT get modified.
The resulting function object (with the updated state) is returned by for_each.

(I assumed you do not insist on using accumulate.)

HTH

Hello,

I was looking something that permit me to do this with accumulate....I don't know how "algorithms" works, so I was thinking that there was some trick with bind1st or other......your for_each avoid me to write a for( ; ;).......

Hello,
See this:

Code:

---

class Value {
 
public:
	double _value;
	bool _missed;
        ...................
};
 
class Feature {
	static std::vector<Value, std::allocator<Value> >&
	sum_vec(std::vector<Value, std::allocator<Value> >& v, const Value& right) {
		if ( !right.getMissed() ) {
			v.push_back(right);						
		}
		return v;		
	}
        ......................................
};
//main.cpp
std::vector<Value, std::allocator<Value> > vVal;
vVal = std::accumulate( _values.begin(), _values.end(), vVal, Feature::sum_vec ); //1
_mean = std::accumulate( vVal.begin(), vVal.end() ) / vVal.size(); //2

---

//1 return vVal that is a new vector that contains only the values that must be summed; (and it is ok)
//2 doesn't compile, because seems vVal.begin() and vVal.end() are not good; Could anyone correct this, please?

However: this isn't the solution that I wanted; I must call 2 accumulate and push_back into a new vector;
I hope this can be a point to reach my aim

Regards,

Why don't you like the for_each version?

as an alternative (if you for some reason insist on using accumulate...):
you can use a structure (not just a double) to hold both the sum and the number of items counted...

something like the following (untested and uncompiled)

Code:

---

struct mean_helper
{
   mean_helper() : count(0), sum(0) {}
   int count;
   double sum;
};
 
static mean_helper sum_and_count(mean_helper h, const Value &right)
{
    if (! right.getMissed())
    {
       ++h.count;
       h.sum += right.value;
    }
    return h;
}
 
mean_helper helper = std::accumulate( _values.begin(), _values.end(), mean_helper(), sum_and_count );
_mean = helper.sum / helper.count;

---

HTH