Btukfyl

I don't know if Boost has more specific functions, but you can do it with the standard library.

Given std::vector<double> v, this is the naive way:

#include <numeric>



double sum = std::accumulate(v.begin(), v.end(), 0.0);

double mean = sum / v.size();



double sq_sum = std::inner_product(v.begin(), v.end(), v.begin(), 0.0);

double stdev = std::sqrt(sq_sum / v.size() - mean * mean);

This is susceptible to overflow or underflow for huge or tiny values. A slightly better way to calculate the standard deviation is:

double sum = std::accumulate(v.begin(), v.end(), 0.0);

double mean = sum / v.size();



std::vector<double> diff(v.size());

std::transform(v.begin(), v.end(), diff.begin(),

               std::bind2nd(std::minus<double>(), mean));

double sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0);

double stdev = std::sqrt(sq_sum / v.size());

UPDATE for C++11:

The call to std::transform can be written using a lambda function instead of std::minus and std::bind2nd(now deprecated):

std::transform(v.begin(), v.end(), diff.begin(), [mean](double x) { return x - mean; });

If performance is important to you, and your compiler supports lambdas, the stdev calculation can be made faster and simpler: In tests with VS 2012 I've found that the following code is over 10 X quicker than the Boost code given in the chosen answer; it's also 5 X quicker than the safer version of the answer using standard libraries given by musiphil.

Note I'm using sample standard deviation, so the below code gives slightly different results (Why there is a Minus One in Standard Deviations)

double sum = std::accumulate(std::begin(v), std::end(v), 0.0);

double m =  sum / v.size();



double accum = 0.0;

std::for_each (std::begin(v), std::end(v), [&](const double d) {

    accum += (d - m) * (d - m);

});



double stdev = sqrt(accum / (v.size()-1));

My answer is similar as Josh Greifer but generalised to sample covariance. Sample variance is just sample covariance but with the two inputs identical. This includes Bessel's correlation.

    template <class Iter> typename Iter::value_type cov(const Iter &x, const Iter &y)

    {

        double sum_x = std::accumulate(std::begin(x), std::end(x), 0.0);

        double sum_y = std::accumulate(std::begin(y), std::end(y), 0.0);



        double mx =  sum_x / x.size();

        double my =  sum_y / y.size();



        double accum = 0.0;



        for (auto i = 0; i < x.size(); i++)

        {

            accum += (x.at(i) - mx) * (y.at(i) - my);

        }



        return accum / (x.size() - 1);

    }

Improving on the answer by musiphil, you can write a standard deviation function without the temporary vector diff, just using a single inner_product call with the C++11 lambda capabilities:

double stddev(std::vector<double> const & func)

{

    double mean = std::accumulate(func.begin(), func.end(), 0.0) / func.size();

    double sq_sum = std::inner_product(func.begin(), func.end(), func.begin(), 0.0,

        (double const & x, double const & y) { return x + y; },

        [mean](double const & x, double const & y) { return (x - mean)*(y - mean); });

    return sq_sum / ( func.size() - 1 );

}

I suspect doing the subtraction multiple times is cheaper than using up additional intermediate storage, and I think it is more readable, but I haven't tested the performance yet.

2x faster than the versions before mentioned - mostly because transform() and inner_product() loops are joined.
Sorry about my shortcut/typedefs/macro: Flo = float. Cit = const iteration. CR const ref. VFlo - vector. Tested in VS2010

Flo     stdDev2(VFlo CR crVec) {

    SZ  n = crVec.size();                               if (n < 2) return 0.0f;

    Flo fSqSum = 0.0f, fSum = 0.0f;

    Cit(VFlo, crVec) {

        Flo f   = *cx;

        fSqSum  += f * f; 

        fSum    += f;

    } 

    Flo fSumSq      = fSum * fSum;

    Flo fSumSqDivN  = fSumSq / n;

    Flo fSubSqSum   = fSqSum - fSumSqDivN;

    Flo preSqrt     = fSubSqSum / (n-1);

    return  sqrt(preSqrt);

}