Existe uma maneira de calcular a média e o desvio padrão para um vetor contendo amostras usando Boost ?
Ou tenho que criar um acumulador e alimentar o vetor nele?
Existe uma maneira de calcular a média e o desvio padrão para um vetor contendo amostras usando Boost ?
Ou tenho que criar um acumulador e alimentar o vetor nele?
Respostas:
Usar acumuladores é a maneira de calcular médias e desvios padrão no Boost .
accumulator_set<double, stats<tag::variance> > acc;
for_each(a_vec.begin(), a_vec.end(), bind<void>(ref(acc), _1));
cout << mean(acc) << endl;
cout << sqrt(variance(acc)) << endl;
second moment - squared mean
que produzirá resultado incorreto se a variância for muito pequena por causa de erros de arredondamento. Na verdade, pode produzir variação negativa.
Não sei se Boost tem funções mais específicas, mas você pode fazer isso com a biblioteca padrão.
Dado std::vector<double> v
, esta é a maneira ingênua:
#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);
Isso é suscetível a estouro ou estouro negativo para valores enormes ou minúsculos. Uma maneira ligeiramente melhor de calcular o desvio padrão é:
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());
ATUALIZAÇÃO para C ++ 11:
A chamada para std::transform
pode ser escrita usando uma função lambda em vez de std::minus
e std::bind2nd
(agora obsoleto):
std::transform(v.begin(), v.end(), diff.begin(), [mean](double x) { return x - mean; });
mean
calculado na parte superior.
(v.size() - 1)
para v.size()
na última linha acima: std::sqrt(sq_sum / (v.size() - 1))
. (Para o primeiro método, que é um pouco complicado: std::sqrt(sq_sum / (v.size() - 1) - mean * mean * v.size() / (v.size() - 1))
.
std::inner_product
para soma de quadrados é muito legal.
Se o desempenho é importante para você, e seu compilador suporta lambdas, o cálculo stdev pode ser feito mais rápido e simples: Em testes com VS 2012 descobri que o código a seguir é 10 vezes mais rápido que o código Boost fornecido na resposta escolhida ; também é 5 X mais rápido do que a versão mais segura da resposta usando bibliotecas padrão fornecidas por musiphil.
Observação Estou usando o desvio padrão da amostra, portanto, o código a seguir fornece resultados ligeiramente diferentes ( por que há um menos em desvios padrão )
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));
std::end()
função foi adicionada pelo padrão C ++ 11 para casos em que não há nada semelhante v.end()
. O std::end
pode ser sobrecarregado para o contêiner menos padrão - consulte en.cppreference.com/w/cpp/iterator/end
Aprimorando a resposta por musiphil , você pode escrever uma função de desvio padrão sem o vetor temporário diff
, apenas usando uma única inner_product
chamada com os recursos lambda do C ++ 11:
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 std::sqrt(sq_sum / ( func.size() - 1 ));
}
Suspeito que fazer a subtração várias vezes é mais barato do que usar o armazenamento intermediário adicional e acho que é mais legível, mas ainda não testei o desempenho.
Parece que a seguinte solução recursiva elegante não foi mencionada, embora já exista há muito tempo. Referindo-se à Arte da Programação de Computador de Knuth,
mean_1 = x_1, variance_1 = 0; //initial conditions; edge case;
//for k >= 2,
mean_k = mean_k-1 + (x_k - mean_k-1) / k;
variance_k = variance_k-1 + (x_k - mean_k-1) * (x_k - mean_k);
então, para uma lista de n>=2
valores, a estimativa do desvio padrão é:
stddev = std::sqrt(variance_n / (n-1)).
Espero que isto ajude!
Minha resposta é semelhante a Josh Greifer, mas generalizada para covariância de amostra. A variância da amostra é apenas a covariância da amostra, mas com as duas entradas idênticas. Isso inclui a correlação de Bessel.
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);
}
2x mais rápido do que as versões mencionadas antes - principalmente porque os loops transform () e inner_product () são unidos. Desculpe pelo meu atalho / typedefs / macro: Flo = float. CR const ref. VFlo - vetor. Testado em VS2010
#define fe(EL, CONTAINER) for each (auto EL in CONTAINER) //VS2010
Flo stdDev(VFlo CR crVec) {
SZ n = crVec.size(); if (n < 2) return 0.0f;
Flo fSqSum = 0.0f, fSum = 0.0f;
fe(f, crVec) fSqSum += f * f; // EDIT: was Cit(VFlo, crVec) {
fe(f, crVec) fSum += f;
Flo fSumSq = fSum * fSum;
Flo fSumSqDivN = fSumSq / n;
Flo fSubSqSum = fSqSum - fSumSqDivN;
Flo fPreSqrt = fSubSqSum / (n - 1);
return sqrt(fPreSqrt);
}
for( float f : crVec ) { fSqSum += f * f; fSum += f; }
?
Crie seu próprio contêiner:
template <class T>
class statList : public std::list<T>
{
public:
statList() : std::list<T>::list() {}
~statList() {}
T mean() {
return accumulate(begin(),end(),0.0)/size();
}
T stddev() {
T diff_sum = 0;
T m = mean();
for(iterator it= begin(); it != end(); ++it)
diff_sum += ((*it - m)*(*it -m));
return diff_sum/size();
}
};
Ele tem algumas limitações, mas funciona perfeitamente quando você sabe o que está fazendo.
// significa desvio em c ++
/ Um desvio que é uma diferença entre um valor observado e o valor verdadeiro de uma quantidade de interesse (como uma média populacional) é um erro e um desvio que é a diferença entre o valor observado e uma estimativa do valor verdadeiro (como uma estimativa pode ser uma média da amostra) é um resíduo. Esses conceitos são aplicáveis para dados nos níveis de intervalo e razão de medição. /
#include <iostream>
#include <conio.h>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv)
{
int i,cnt;
cout<<"please inter count:\t";
cin>>cnt;
float *num=new float [cnt];
float *s=new float [cnt];
float sum=0,ave,M,M_D;
for(i=0;i<cnt;i++)
{
cin>>num[i];
sum+=num[i];
}
ave=sum/cnt;
for(i=0;i<cnt;i++)
{
s[i]=ave-num[i];
if(s[i]<0)
{
s[i]=s[i]*(-1);
}
cout<<"\n|ave - number| = "<<s[i];
M+=s[i];
}
M_D=M/cnt;
cout<<"\n\n Average: "<<ave;
cout<<"\n M.D(Mean Deviation): "<<M_D;
getch();
return 0;
}