tested ok

Hacene SI HADJ MOHAND
1 parent 1d0339b8
Showing 5 changed files with 505 additions and 18 deletions Show diff stats
src/ExternLib/StatisticProcesses/AMDAPlugin.cc
src/ExternLib/StatisticProcesses/CountStatistic.hh
src/ExternLib/StatisticProcesses/CountStatisticProcess.cc
src/ExternLib/StatisticProcesses/CountStatisticProcess.hh
src/ExternLib/StatisticProcesses/MinMaxMeanStatistic.hh
@@ -52,6 +52,8 @@ DESCRIPTION
 #include "PluginManager.hh"
 #include "MinMaxMeanStatisticProcess.hh"
 #include "MinVarStatisticProcess.hh"
+#include "CountStatisticProcess.hh"
+#include "CountStatistic.hh"
  
 using namespace AMDA::Parameters;
  
@@ -102,4 +104,10 @@ extern &quot;C&quot; void registerPlugin(AMDA::Plugins::PluginManager &amp; /*pm*/)
  
                     StatisticProcessFactory factKurtosisProcess = boost::factory<AMDA::Statistic::MinMaxMean::KurtosisStatisticProcess*>();
 	ServicesServer::getInstance()->addStatisticProcessFactory("kurtosis", factKurtosisProcess);
+        
+                   StatisticProcessFactory factCountProcess = boost::factory<AMDA::Statistic::Count::CountStatisticProcess*>();
+	ServicesServer::getInstance()->addStatisticProcessFactory("count", factCountProcess);
+        
+                    StatisticProcessFactory factCountNotNanProcess = boost::factory<AMDA::Statistic::Count::CountNotNanStatisticProcess*>();
+	ServicesServer::getInstance()->addStatisticProcessFactory("countNotNan", factCountNotNanProcess);
 }
@@ -0,0 +1,329 @@
+
+/* 
+ * File:   CountStatistic.hh
+ * Author: AKKA
+ *
+ * Created on December 20, 2019, 1:44 PM
+ */
+
+#ifndef COUNTSTATISTIC_HH
+#define COUNTSTATISTIC_HH
+
+#include "ParamData.hh"
+#include "DataTypeMath.hh"
+#include "VisitorOfParamData.hh"
+#include "StatisticData.hh"
+#include "StatisticOperation.hh"
+#include "StatisticProcess.hh"
+#include <math.h>
+#include "TimeInterval.hh"
+
+namespace AMDA {
+    namespace Statistic {
+        namespace Count {
+
+            using namespace AMDA::Parameters;
+
+            typedef enum {
+                FT_COUNT,
+                FT_COUNT_NOT_NAN
+            } COUNT_FUNC_TYPE;
+
+            template <typename TParamData, typename TResultData>
+            class CountStatisticOperation : public StatisticOperation<TResultData> {
+            public:
+                typedef typename TParamData::ElementType ElementType;
+
+                CountStatisticOperation(StatisticProcess& process,
+                        TimeIntervalListSPtr pTimeIntervalList, TParamData &param,  COUNT_FUNC_TYPE funcType) :
+                StatisticOperation<TResultData>(process),
+                _paramInput(param), _timeIntervalList(pTimeIntervalList),
+                _currentTimeInterval(_timeIntervalList->begin()),
+                _funcType(funcType), _dimDef("unknown") {
+                    resetData(StatisticOperation<TResultData>::_resultData);
+                }
+
+                virtual ~CountStatisticOperation(void) {
+                }
+
+                virtual void compute(ParamDataIndexInfo &pParamDataIndexInfo) {
+                    for (unsigned int index = pParamDataIndexInfo._startIndex;
+                            index < pParamDataIndexInfo._startIndex
+                            + pParamDataIndexInfo._nbDataToProcess;
+                            index++) {
+                        _val = _paramInput.get(index);
+                        switch (_funcType) {
+                            case FT_COUNT:
+                                count(_val);
+                                break;
+                            case FT_COUNT_NOT_NAN:
+                                count(_val, "NotNan");
+                                break;
+                        }
+                    }
+                }
+
+                virtual void finalizeCompute(void) {
+                    if (_funcType == FT_COUNT || _funcType == FT_COUNT_NOT_NAN) {
+                        finalizeCountResult(StatisticOperation<TResultData>::_resultData);
+                    }
+                }
+
+                virtual std::string getResultDimDefinition(bool /* forCoverage */) {
+                    return _dimDef.str();
+                }
+
+                virtual void reset() {
+                    StatisticOperation<TResultData>::reset();
+                    resetData(StatisticOperation<TResultData>::_resultData);
+                }
+            private:
+
+                template<typename Type>
+                void resetData(Type &a) {
+                    a._result << NotANumber();
+                    a._nbDataProcessed = 0;
+                }
+
+                template<typename Type>
+                void resetData(std::vector<Type> &a) {
+                    a.clear();
+                }
+
+                template<typename Type>
+                void count(Type &a, std::string mode = " ") {
+                    _dimDef.str("1");
+                    if (mode == "NotNan" && isNAN(a))
+                        return;
+                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
+                }
+
+                template<typename Type>
+                void count(std::vector<Type> &a, std::string mode = " ") {
+                    if (StatisticOperation<TResultData>::_resultData.empty()) {
+                        _dimDef.str("");
+                        _dimDef << a.size();
+                        for (unsigned int i = 0; i < a.size(); ++i) {
+                            StatisticDataScalar<int> data;
+                            resetData(data);
+                            if (!isNAN(a[i]) || mode == " ")
+                                ++data._nbDataProcessed;
+                            StatisticOperation<TResultData>::_resultData.push_back(data);
+                        }
+                        return;
+                    }
+                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
+                        if (isNAN(a[i]) && mode == "NotNan")
+                            continue;
+                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
+                    }
+                }
+
+                template<typename Type>
+                void finalizeCountResult(Type &a) {
+                    if (!isNAN(a._nbDataProcessed))
+                        a._result = a._nbDataProcessed;
+                }
+
+                template<typename Type>
+                void finalizeCountResult(std::vector<Type> &a) {
+                    for (int i = 0; i < a.size(); i++)
+                        finalizeCountResult(a[i]);
+                }
+
+                /**
+                 * @brief real ParamData Input
+                 */
+                TParamData& _paramInput;
+
+                TimeIntervalListSPtr _timeIntervalList;
+
+                TimeIntervalList::iterator _currentTimeInterval;
+
+                ElementType _val;
+
+                 COUNT_FUNC_TYPE _funcType;
+
+                std::stringstream _dimDef;
+
+            }; //Class Count
+
+            class CreateCountStatistic : public VisitorOfParamData {
+            public:
+
+                CreateCountStatistic(StatisticProcess& pProcess,
+                        TimeIntervalListSPtr pTimeIntervalList,
+                        ParamData &paramData, COUNT_FUNC_TYPE type) :
+                _process(pProcess), _timeIntervalList(pTimeIntervalList),
+                _paramData(paramData), _operation(NULL), _type(type) {
+                    _paramData.accept(*this);
+                }
+
+                StatisticOperationBase* getStatisticOperation(void) {
+                    return _operation;
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataScalaireShort *)
+                 */
+                virtual void visit(ParamDataScalaireShort *) {
+                    _operation = new CountStatisticOperation<ParamDataScalaireShort, StatisticDataScalar<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataScalaireShort &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
+                 */
+                virtual void visit(ParamDataScalaireFloat *) {
+                    _operation = new CountStatisticOperation<ParamDataScalaireFloat, StatisticDataScalar<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataScalaireFloat &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
+                 */
+                virtual void visit(ParamDataScalaireDouble *) {
+                    _operation = new CountStatisticOperation<ParamDataScalaireDouble, StatisticDataScalar<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataScalaireDouble &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
+                 */
+                virtual void visit(ParamDataScalaireLongDouble *) {
+                    _operation = new CountStatisticOperation<ParamDataScalaireLongDouble, StatisticDataScalar<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataScalaireLongDouble &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
+                 */
+                virtual void visit(ParamDataScalaireInt *) {
+                    _operation = new CountStatisticOperation<ParamDataScalaireInt, StatisticDataScalar<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataScalaireInt &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataLogicalData *)
+                 */
+                virtual void visit(ParamDataLogicalData *) {
+                    BOOST_THROW_EXCEPTION(
+                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN)
+                            << AMDA::ex_msg(
+                            "CreateStatistic operation not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DShort *)
+                 */
+                virtual void visit(ParamDataTab1DShort *) {
+                    _operation = new CountStatisticOperation<ParamDataTab1DShort, StatisticDataVector<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataTab1DShort &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
+                 */
+                virtual void visit(ParamDataTab1DFloat *) {
+                    _operation = new CountStatisticOperation<ParamDataTab1DFloat, StatisticDataVector<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataTab1DFloat &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
+                 */
+                virtual void visit(ParamDataTab1DDouble *) {
+                    _operation = new CountStatisticOperation<ParamDataTab1DDouble, StatisticDataVector<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataTab1DDouble &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
+                 */
+                virtual void visit(ParamDataTab1DLongDouble *) {
+                    _operation = new CountStatisticOperation<ParamDataTab1DLongDouble, StatisticDataVector<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataTab1DLongDouble &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
+                 */
+                virtual void visit(ParamDataTab1DInt *) {
+                    _operation = new CountStatisticOperation<ParamDataTab1DInt, StatisticDataVector<int>>(_process,
+                            _timeIntervalList, dynamic_cast<ParamDataTab1DInt &> (_paramData), _type);
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab1DLogicalData *)
+                 */
+                virtual void visit(ParamDataTab1DLogicalData *) {
+                    BOOST_THROW_EXCEPTION(
+                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN)
+                            << AMDA::ex_msg(
+                            "CreateStatistic operation not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
+                 */
+                virtual void visit(ParamDataTab2DShort *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DShort data not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
+                 */
+                virtual void visit(ParamDataTab2DFloat *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DFloat data not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
+                 */
+                virtual void visit(ParamDataTab2DDouble *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DDouble data not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
+                 */
+                virtual void visit(ParamDataTab2DLongDouble *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DLongDouble data not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
+                 */
+                virtual void visit(ParamDataTab2DInt *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DInt data not supported"));
+                }
+
+                /**
+                 * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
+                 */
+                virtual void visit(ParamDataTab2DLogicalData *) {
+                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DLogicalData data not supported"));
+                }
+
+            private:
+                StatisticProcess& _process;
+
+                TimeIntervalListSPtr& _timeIntervalList;
+
+                ParamData &_paramData;
+
+                StatisticOperationBase *_operation;
+
+                COUNT_FUNC_TYPE _type;
+
+
+            };
+
+        }//Count
+    }//STATISTIC
+} //AMDA
+
+
+
+#endif /* COUNTSTATISTIC_HH */
+
@@ -0,0 +1,45 @@
+#include "CountStatisticProcess.hh"
+
+#include "CountStatistic.hh"
+
+namespace AMDA {
+    namespace Statistic {
+        namespace Count {
+
+            CountStatisticProcess::CountStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
+            AMDA::Parameters::StatisticProcess(parameter, false, index) {
+            }
+
+            CountStatisticProcess::~CountStatisticProcess(void) {
+            }
+
+            void CountStatisticProcess::createOperation(void) {
+                AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
+                CreateCountStatistic lCreateCountStatistic(*this, _timeIntervalList, *paramInput, COUNT_FUNC_TYPE::FT_COUNT);
+                _operation = lCreateCountStatistic.getStatisticOperation();
+            }
+
+            std::string CountStatisticProcess::getUCD(void) {
+                return "stat.count";
+            }
+            
+                        CountNotNanStatisticProcess::CountNotNanStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
+            AMDA::Parameters::StatisticProcess(parameter, false, index) {
+            }
+
+            CountNotNanStatisticProcess::~CountNotNanStatisticProcess(void) {
+            }
+
+            void CountNotNanStatisticProcess::createOperation(void) {
+                AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
+                CreateCountStatistic lCreateCountStatistic(*this, _timeIntervalList, *paramInput, COUNT_FUNC_TYPE::FT_COUNT_NOT_NAN);
+                _operation = lCreateCountStatistic.getStatisticOperation();
+            }
+
+            std::string CountNotNanStatisticProcess::getUCD(void) {
+                return "stat.countNotNan";
+            }
+
+        }
+    }
+}
 \ No newline at end of file
@@ -0,0 +1,87 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/* 
+ * File:   CountStatisticProcess.hh
+ * Author: AKKA 
+ *
+ * Created on December 20, 2019, 1:42 PM
+ */
+
+#ifndef COUNTSTATISTICPROCESS_HH
+#define COUNTSTATISTICPROCESS_HH
+
+#include "StatisticProcess.hh"
+
+namespace AMDA {
+namespace Statistic {
+namespace Count {
+
+/**
+ * @class CountStatisticProcess
+ * @brief Process to compute COUNT value
+ */
+class CountStatisticProcess : public AMDA::Parameters::StatisticProcess
+{
+public:
+	/*
+	 * @brief constructor
+	 */
+	CountStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index);
+
+	/*
+	 * @brief destructor
+	 */
+	virtual ~CountStatisticProcess(void);
+
+	/*
+	 * @brief create min statistic operation
+	 */
+	virtual void createOperation(void);
+
+	/*
+	 * @brief get UCD of the process
+	 */
+	std::string getUCD(void);
+};
+
+/**
+ * @class CountStatisticProcess
+ * @brief Process to compute COUNT value
+ */
+class CountNotNanStatisticProcess : public AMDA::Parameters::StatisticProcess
+{
+public:
+	/*
+	 * @brief constructor
+	 */
+	CountNotNanStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index);
+
+	/*
+	 * @brief destructor
+	 */
+	virtual ~CountNotNanStatisticProcess(void);
+
+	/*
+	 * @brief create min statistic operation
+	 */
+	virtual void createOperation(void);
+
+	/*
+	 * @brief get UCD of the process
+	 */
+	std::string getUCD(void);
+};
+
+
+
+} // Count
+} // Statistic 
+} // AMDA
+
+
+#endif /* COUNTSTATISTICPROCESS_HH */
+
@@ -74,12 +74,15 @@ namespace AMDA {
                                 generateVector(_val);
                                 break;
                             case FT_VARIANCE:
+                                addForMean(_val);
                                 generateVector(_val);
                                 break;
                             case FT_SKEWNESS:
+                                addForMean(_val);
                                 generateVector(_val);
                                 break;
                             case FT_KURTOSIS:
+                                addForMean(_val);
                                 generateVector(_val);
                                 break;
                         }
@@ -96,9 +99,11 @@ namespace AMDA {
                     finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                     }else if (_funcType == FT_SKEWNESS){
                         finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
+                        finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                         finalizeSkewnessResult(StatisticOperation<TResultData>::_resultData);
                     }else if (_funcType == FT_KURTOSIS){
                         finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
+                        finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                         finalizeKurtosisResult(StatisticOperation<TResultData>::_resultData);
                     }
                 }
@@ -306,12 +311,15 @@ namespace AMDA {
                     if (a._nbDataProcessed > 0)
                         if (!isNAN(a._result))
                             a._result /= a._nbDataProcessed;
+                    _mean = a._result;
                 }
  
                 template<typename Type>
                 void finalizeMeanResult(std::vector<Type>& a) {
-                    for (unsigned int i = 0; i < a.size(); ++i)
-                        finalizeMeanResult(a[i]);
+                    for (unsigned int i = 0; i < a.size(); ++i){
+                             a[i]._result /= a[i]._nbDataProcessed;
+                    _mean.push_back(a[i]._result);
+                    }
                 }
  
                 template<typename Type>
@@ -348,9 +356,10 @@ namespace AMDA {
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - a._result) * (d - a._result);
+                        accum += (d - _mean) * (d - _mean);
                     });
-                    a._result = accum/(_dataList.size()-1);
+                    a._result = accum/(_dataList.size());
+                    _standardDeviation = sqrt(a._result);
                 }
  
                 template<typename Type>
@@ -360,57 +369,62 @@ namespace AMDA {
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
-                        accum += (d - a[i]._result) * (d - a[i]._result);
+                        accum += (d - _mean[i]) * (d - _mean[i]);
                     });
-                    a[i]._result = accum/(_dataList[i].size()-1);
+                    a[i]._result = accum/(_dataList[i].size());
+                    _standardDeviation.push_back(sqrt(a[i]._result));
                     }
                 }
  
                 template<typename Type>
                 void finalizeSkewnessResult(Type & a) {
-                    if (_dataList.size() == 0)
+                    int n = _dataList.size();
+                    if (n == 0)
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - a._result) * (d - a._result) * (d - a._result);
+                        accum += (d - _mean) * (d - _mean) * (d - _mean);
                     });
-                    a._result = accum/(_dataList.size()-1);
+                    a._result = n/((double) (n-1)*(n-2))*accum/pow(_standardDeviation, 3);
                 }
  
                 template<typename Type>
                 void finalizeSkewnessResult(std::vector<Type> & a) {
                     for(int i = 0; i < a.size(); i++){
-                    if (_dataList[i].size() == 0)
+                    int n = _dataList[i].size();
+                    if (n == 0)
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
-                        accum += (d - a[i]._result) * (d - a[i]._result) * (d - a[i]._result);
+                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]);
                     });
-                    a[i]._result = accum/(_dataList[i].size()-1);
+                    a[i]._result = n/((double) (n-1)*(n-2))*accum/pow(_standardDeviation[i], 3);
                     }
                 }
  
                 template<typename Type>
                 void finalizeKurtosisResult(Type & a) {
-                    if (_dataList.size() == 0)
+                    int n = _dataList.size();
+                    if (n == 0)
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - a._result) * (d - a._result) * (d - a._result) * (d - a._result);;
+                        accum += (d - _mean) * (d - _mean) * (d - _mean) * (d - _mean)/pow(_standardDeviation,4);
                     });
-                    a._result = accum/(_dataList.size()-1);
+                    a._result = n*(n+1)/((double)(n-1)*(n-2)*(n-3))*accum- 3*(n-1)*(n-1)/((double)(n-2)*(n-3));
                 }
  
                 template<typename Type>
                 void finalizeKurtosisResult(std::vector<Type> & a) {
                     for(int i = 0; i < a.size(); i++){
-                    if (_dataList[i].size() == 0)
+                        int n = _dataList[i].size();
+                    if ( n == 0)
                         return;
                     double accum = 0.0;
                     std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
-                        accum += (d - a[i]._result) * (d - a[i]._result) * (d - a[i]._result) * (d - a[i]._result);;
+                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i])/pow(_standardDeviation[i],4);
                     });
-                    a[i]._result = accum/(_dataList[i].size()-1);
+                    a[i]._result = n*(n+1)/((double)(n-1)*(n-2)*(n-3))*accum- 3*(n-1)*(n-1)/((double)(n-2)*(n-3));
                     }
                 }
  
@@ -424,6 +438,10 @@ namespace AMDA {
                 TimeIntervalList::iterator _currentTimeInterval;
  
                 ElementType _val;
+                
+                ElementType _mean; 
+                
+                ElementType _standardDeviation;
  
                 std::vector<ElementType> _dataList;