99

Boostを使用してサンプルを含むベクトルの平均と標準偏差を計算する方法はありますか？

または、アキュムレータを作成してそれにベクトルをフィードする必要がありますか？

4

10 に答える 10

240

Boostがより具体的な機能を持っているかどうかはわかりませんが、標準ライブラリでそれを行うことができます。

与えられstd::vector<double> vた、これは素朴な方法です：

#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);

これは、大きな値または小さな値のオーバーフローまたはアンダーフローの影響を受けやすくなります。標準偏差を計算するためのもう少し良い方法は次のとおりです。

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());

C ++ 11の更新：

の呼び出しは、 and （現在は非推奨）std::transformの代わりにラムダ関数を使用して記述できます。std::minusstd::bind2nd

std::transform(v.begin(), v.end(), diff.begin(), [mean](double x) { return x - mean; });
于 2011-09-30T22:42:43.610 に答える
73

パフォーマンスが重要であり、コンパイラがラムダをサポートしている場合、stdevの計算をより速く簡単に行うことができます。VS2012を使用したテストでは、次のコードは、選択した回答で指定されたBoostコードよりも10倍以上高速であることがわかりました。 ; また、musiphilが提供する標準ライブラリを使用した、より安全なバージョンの回答よりも5倍高速です。

サンプルの標準偏差を使用しているため、以下のコードではわずかに異なる結果が得られることに注意してください（標準偏差にマイナス1がある理由）

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));
于 2012-09-13T12:01:37.200 に答える
56

アキュムレータの使用は、 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;

 

于 2011-09-30T22:48:36.883 に答える
7

musiphilによる回答を改善すると、C ++ 11ラムダ機能diffを使用した1回の呼び出しを使用するだけで、一時ベクトルなしで標準偏差関数を記述できます。inner_product

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());
}

減算を複数回行う方が、追加の中間ストレージを使い切るよりも安価だと思います。読みやすいと思いますが、まだパフォーマンスをテストしていません。

于 2018-08-13T13:31:20.857 に答える
5

次のエレガントな再帰的解決策は、長い間存在していましたが、言及されていないようです。クヌースのコンピュータプログラミングの芸術を参照して、

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);

次に、値のリストのn>=2場合、標準偏差の推定値は次のとおりです。

stddev = std::sqrt(variance_n / (n-1)).

お役に立てれば！

于 2019-03-14T06:04:52.713 に答える
1

私の答えはJoshGreiferに似ていますが、サンプルの共分散に一般化されています。サンプル分散は単なるサンプル共分散ですが、2つの入力は同じです。これには、ベッセルの相関関係が含まれます。

    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);
    }
于 2015-04-22T12:38:24.883 に答える
0

前述のバージョンより2倍高速です-主にtransform（）ループとinner_product（）ループが結合されているためです。私のshortcut/typedefs / macroについて申し訳ありません：Flo=float。CRconstref。VFlo-ベクトル。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);
}
于 2017-10-25T02:46:28.157 に答える
0

より良い予測でサンプル平均を計算するために、次のrステップ再帰を使用できます。

mean_k = 1 / k * [（kr）* mean_（kr）+ sum_over_i_from_（n-r + 1）_to_n（x_i）]、

ここで、rは、合計コンポーネントを互いに近づけるために選択されます。

于 2021-06-24T13:37:14.100 に答える
-3

独自のコンテナを作成します。

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();
        }
};

いくつかの制限がありますが、自分が何をしているのかを知っていると、美しく機能します。

于 2016-08-08T22:50:29.793 に答える
-7

//C++での偏差を意味します

/関心のある量（母平均など）の観測値と真の値の差である偏差は誤差であり、観測値と真の値の推定値（推定値はサンプル平均である可能性があります）は残差です。これらの概念は、測定の間隔と比率のレベルのデータに適用できます。/

#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;

}

于 2016-08-07T08:24:15.590 に答える