us ok

Hacene SI HADJ MOHAND
1 parent 2ed0b752
Showing 1 changed file with 320 additions and 309 deletions Show diff stats
src/ExternLib/StatisticProcesses/MinMaxMeanStatistic.hh
@@ -47,8 +47,8 @@ namespace AMDA {
                  */
                 typedef typename TParamData::ElementType ElementType;
  
-              
-                using TimeDataList = std::vector<std::pair<double,  ElementType>>;
+
+                using TimeDataList = std::vector<std::pair<double, ElementType>>;
  
                 MinMaxMeanStatisticOperation(StatisticProcess& process,
                         TimeIntervalListSPtr pTimeIntervalList, TParamData &param, FUNC_TYPE funcType) :
@@ -131,7 +131,9 @@ namespace AMDA {
                         finalizeKurtosisResult(StatisticOperation<TResultData>::_resultData);
                     } else if (_funcType == FT_FIRST_VALUE) {
                         finalizeFirstValueResult(StatisticOperation<TResultData>::_resultData);
-                    }else if (_funcType == FT_LAST_VALUE) {
+                    }else if (_funcType == FT_MIDDLE_VALUE) {
+                        finalizeMiddleValueResult(StatisticOperation<TResultData>::_resultData);
+                    } else if (_funcType == FT_LAST_VALUE) {
                         finalizeLastValueResult(StatisticOperation<TResultData>::_resultData);
                     }
                 }
@@ -403,12 +405,11 @@ namespace AMDA {
                         }
                     }
                     // fill timeDataList
-                    for (int i = 0; i < a.size(); i++) {
-                        std::vector<Type> vec;
-                        vec.push_back(a[i]);
-                        _timeDataList.push_back(std::make_pair(time, vec));
-                        vec.clear();
-                    }
+                    std::vector<Type> vec;
+                    for (int i = 0; i < a.size(); i++) 
+                         vec.push_back(a[i]);
+                     _timeDataList.push_back(std::make_pair(time, vec));
+                     vec.clear();
                 }
  
                 template<typename Type>
@@ -503,7 +504,6 @@ namespace AMDA {
                     }
                 }
  
-                /*
                 template<typename Type>
                 void finalizeMiddleValueResult(Type & a) {
                     if (_timeDataList.size() == 0)
@@ -512,7 +512,17 @@ namespace AMDA {
                         a._result = _timeDataList[0].second;
                         return;
                     } else {
-                        a._result = getMiddleValue(_timeDataList);
+                        double middeTime = (_timeDataList.front().first + _timeDataList.back().first) / 2;
+                        for (int i = 0; i < _timeDataList.size(); i++) {
+                            if (_timeDataList[i].first == middeTime) {
+                                a._result = _timeDataList[i].second;
+                                return;
+                            } else if (_timeDataList[i].first > middeTime) {
+                                a._result = _timeDataList[i - 1].second + (_timeDataList[i].second - _timeDataList[i - 1].second)*
+                                        ((middeTime - _timeDataList[i - 1].first) / (_timeDataList[i].first - _timeDataList[i - 1].first));
+                                return;
+                            }
+                        }
                     }
                 }
  
@@ -520,319 +530,320 @@ namespace AMDA {
                 void finalizeMiddleValueResult(std::vector<Type> & a) {
  
                     //vector of pair <time dataScalar>
-                    std::vector<std::pair<double, Type>>  timeDataList;
-                    for (int i = 0; i < a.size(); i++) {                                              
+                    std::vector<std::pair<double, double>> timeDataList;
+                    for (int i = 0; i < a.size(); i++) {
                         for (auto val : _timeDataList) {
-                            if (!isNAN(val.second[i])){
-                                
-                                timeDataList.push_back(std::make_pair(val.first,  val.second[i]));
-                            }
-                        }
-                        if (timeDataList.size() == 0)
-                            continue;
-                        a[i].result = getMiddleValue(timeDataList);
-                        timeDataList.clear();
-                    }
-                }
-                 
-
-                template<typename Type>
-                Type getMiddleValue(std::vector<std::pair<double, StatisticDataScalar<Type> >>  time1DDataList) {
-                    if (time1DDataList.size() == 1) {
-                        return time1DDataList[0].second;
-                    }
-                    double middeTime = (time1DDataList.front().first + time1DDataList.back().first) / 2;
-                    for (int i = 0; i < time1DDataList.size(); i++) {
-                        if (time1DDataList[i].first == middeTime) {
-                            return time1DDataList[i].second;
-                        } else if (time1DDataList[i].first > middeTime) {
-                            return time1DDataList[i - 1].second + (time1DDataList[i].second - time1DDataList[i - 1].second)*
-                                    ((middeTime - time1DDataList[i - 1].first) / (time1DDataList[i].first - time1DDataList[i - 1].first));
-
+                            if (!isNAN(val.second[i]))
+                                timeDataList.push_back(std::make_pair(val.first, (double) val.second[i]));
                         }
+                    
+                    if (timeDataList.size() == 0)
+                        continue;
+                    a[i]._result = getMiddleValue(timeDataList);
+                    timeDataList.clear();
+                }
+                }
+            
+
+            double getMiddleValue(std::vector<std::pair<double, double >> time1DDataList) {
+                if (time1DDataList.size() == 1) {
+                    return time1DDataList[0].second;
+                }
+                double middeTime = (time1DDataList.front().first + time1DDataList.back().first) / 2;
+                double res = std::numeric_limits<double>::quiet_NaN();
+                for (int i = 0; i < time1DDataList.size(); i++) {
+                    if (time1DDataList[i].first == middeTime) {
+                        res= time1DDataList[i].second;
+                        break;
+                    } else if (time1DDataList[i].first > middeTime) {
+                        res = time1DDataList[i - 1].second + (time1DDataList[i].second - time1DDataList[i - 1].second)*
+                                ((middeTime - time1DDataList[i - 1].first) / (time1DDataList[i].first - time1DDataList[i - 1].first));
+                        break;
                     }
                 }
-*/
-                template<typename Type>
-                void finalizeVarianceResult(Type & a) {
-                    if (_dataList.size() == 0)
+                return res;
+            }
+
+            template<typename Type>
+            void finalizeVarianceResult(Type & a) {
+                if (_dataList.size() == 0)
+                    return;
+                double accum = 0.0;
+                std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
+                    accum += (d - _mean) * (d - _mean);
+                });
+                a._result = accum / (_dataList.size());
+                _standardDeviation = sqrt(a._result);
+            }
+
+            template<typename Type>
+            void finalizeVarianceResult(std::vector<Type> & a) {
+                for (int i = 0; i < a.size(); i++) {
+                    if (_dataList[i].size() == 0)
                         return;
                     double accum = 0.0;
-                    std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - _mean) * (d - _mean);
+                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
+                        accum += (d - _mean[i]) * (d - _mean[i]);
                     });
-                    a._result = accum / (_dataList.size());
-                    _standardDeviation = sqrt(a._result);
-                }
-
-                template<typename Type>
-                void finalizeVarianceResult(std::vector<Type> & a) {
-                    for (int i = 0; i < a.size(); i++) {
-                        if (_dataList[i].size() == 0)
-                            return;
-                        double accum = 0.0;
-                        std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
-                            accum += (d - _mean[i]) * (d - _mean[i]);
-                        });
-                        a[i]._result = accum / (_dataList[i].size());
-                        _standardDeviation.push_back(sqrt(a[i]._result));
-                    }
-                }
-
-                template<typename Type>
-                void finalizeSkewnessResult(Type & a) {
-                    int n = _dataList.size();
+                    a[i]._result = accum / (_dataList[i].size());
+                    _standardDeviation.push_back(sqrt(a[i]._result));
+                }
+            }
+
+            template<typename Type>
+            void finalizeSkewnessResult(Type & a) {
+                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 - _mean) * (d - _mean) * (d - _mean);
+                });
+                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++) {
+                    int n = _dataList[i].size();
                     if (n == 0)
                         return;
                     double accum = 0.0;
-                    std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - _mean) * (d - _mean) * (d - _mean);
+                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
+                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]);
                     });
-                    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++) {
-                        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 - _mean[i]) * (d - _mean[i]) * (d - _mean[i]);
-                        });
-                        a[i]._result = n / ((double) (n - 1)*(n - 2)) * accum / pow(_standardDeviation[i], 3);
-                    }
-                }
-
-                template<typename Type>
-                void finalizeKurtosisResult(Type & a) {
-                    int n = _dataList.size();
+                    a[i]._result = n / ((double) (n - 1)*(n - 2)) * accum / pow(_standardDeviation[i], 3);
+                }
+            }
+
+            template<typename Type>
+            void finalizeKurtosisResult(Type & a) {
+                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 - _mean) * (d - _mean) * (d - _mean) * (d - _mean) / pow(_standardDeviation, 4);
+                });
+                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++) {
+                    int n = _dataList[i].size();
                     if (n == 0)
                         return;
                     double accum = 0.0;
-                    std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
-                        accum += (d - _mean) * (d - _mean) * (d - _mean) * (d - _mean) / pow(_standardDeviation, 4);
+                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
+                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) / pow(_standardDeviation[i], 4);
                     });
-                    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++) {
-                        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 - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) / pow(_standardDeviation[i], 4);
-                        });
-                        a[i]._result = n * (n + 1) / ((double) (n - 1)*(n - 2)*(n - 3)) * accum - 3 * (n - 1)*(n - 1) / ((double) (n - 2)*(n - 3));
-                    }
-                }
-
-                /**
-                 * @brief real ParamData Input
-                 */
-                TParamData& _paramInput;
-
-                TimeIntervalListSPtr _timeIntervalList;
-
-                TimeIntervalList::iterator _currentTimeInterval;
-
-                ElementType _val;
-
-                ElementType _mean;
-
-                ElementType _standardDeviation;
-
-                std::vector<ElementType> _dataList;
-
-                /*
-                 * vector of pair<time, data> 
-                 */
-                TimeDataList _timeDataList;
-
-
-                FUNC_TYPE _funcType;
-
-                std::stringstream _dimDef;
-            };
-
-            class CreateMinMaxMeanStatistic : public VisitorOfParamData {
-            public:
-
-                /**
-                 * @brief constructor
-                 */
-                CreateMinMaxMeanStatistic(StatisticProcess& pProcess,
-                        TimeIntervalListSPtr pTimeIntervalList,
-                        ParamData &paramData, 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 MinMaxMeanStatisticOperation<ParamDataScalaireShort, StatisticDataScalar<short>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataScalaireShort &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
-                 */
-                virtual void visit(ParamDataScalaireFloat *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireFloat, StatisticDataScalar<float>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataScalaireFloat &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
-                 */
-                virtual void visit(ParamDataScalaireDouble *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireDouble, StatisticDataScalar<double>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataScalaireDouble &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
-                 */
-                virtual void visit(ParamDataScalaireLongDouble *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireLongDouble, StatisticDataScalar<long double>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataScalaireLongDouble &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
-                 */
-                virtual void visit(ParamDataScalaireInt *) {
-                    _operation = new MinMaxMeanStatisticOperation<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 MinMaxMeanStatisticOperation<ParamDataTab1DShort, StatisticDataVector<short>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataTab1DShort &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
-                 */
-                virtual void visit(ParamDataTab1DFloat *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DFloat, StatisticDataVector<float>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataTab1DFloat &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
-                 */
-                virtual void visit(ParamDataTab1DDouble *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DDouble, StatisticDataVector<double>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataTab1DDouble &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
-                 */
-                virtual void visit(ParamDataTab1DLongDouble *) {
-                    _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DLongDouble, StatisticDataVector<long double>>(_process,
-                            _timeIntervalList, dynamic_cast<ParamDataTab1DLongDouble &> (_paramData), _type);
-                }
-
-                /**
-                 * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
-                 */
-                virtual void visit(ParamDataTab1DInt *) {
-                    _operation = new MinMaxMeanStatisticOperation<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;
-
-                FUNC_TYPE _type;
-            };
-
-        } /* namespace MinMaxMean */
-    } /* namespace Statistic */
+                    a[i]._result = n * (n + 1) / ((double) (n - 1)*(n - 2)*(n - 3)) * accum - 3 * (n - 1)*(n - 1) / ((double) (n - 2)*(n - 3));
+                }
+            }
+
+            /**
+             * @brief real ParamData Input
+             */
+            TParamData& _paramInput;
+
+            TimeIntervalListSPtr _timeIntervalList;
+
+            TimeIntervalList::iterator _currentTimeInterval;
+
+            ElementType _val;
+
+            ElementType _mean;
+
+            ElementType _standardDeviation;
+
+            std::vector<ElementType> _dataList;
+
+            /*
+             * vector of pair<time, data> 
+             */
+            TimeDataList _timeDataList;
+
+
+            FUNC_TYPE _funcType;
+
+            std::stringstream _dimDef;
+        };
+
+        class CreateMinMaxMeanStatistic : public VisitorOfParamData {
+        public:
+
+            /**
+             * @brief constructor
+             */
+            CreateMinMaxMeanStatistic(StatisticProcess& pProcess,
+                    TimeIntervalListSPtr pTimeIntervalList,
+                    ParamData &paramData, 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 MinMaxMeanStatisticOperation<ParamDataScalaireShort, StatisticDataScalar<short>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataScalaireShort &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
+             */
+            virtual void visit(ParamDataScalaireFloat *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireFloat, StatisticDataScalar<float>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataScalaireFloat &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
+             */
+            virtual void visit(ParamDataScalaireDouble *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireDouble, StatisticDataScalar<double>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataScalaireDouble &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
+             */
+            virtual void visit(ParamDataScalaireLongDouble *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireLongDouble, StatisticDataScalar<long double>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataScalaireLongDouble &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
+             */
+            virtual void visit(ParamDataScalaireInt *) {
+                _operation = new MinMaxMeanStatisticOperation<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 MinMaxMeanStatisticOperation<ParamDataTab1DShort, StatisticDataVector<short>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataTab1DShort &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
+             */
+            virtual void visit(ParamDataTab1DFloat *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DFloat, StatisticDataVector<float>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataTab1DFloat &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
+             */
+            virtual void visit(ParamDataTab1DDouble *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DDouble, StatisticDataVector<double>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataTab1DDouble &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
+             */
+            virtual void visit(ParamDataTab1DLongDouble *) {
+                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DLongDouble, StatisticDataVector<long double>>(_process,
+                        _timeIntervalList, dynamic_cast<ParamDataTab1DLongDouble &> (_paramData), _type);
+            }
+
+            /**
+             * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
+             */
+            virtual void visit(ParamDataTab1DInt *) {
+                _operation = new MinMaxMeanStatisticOperation<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;
+
+            FUNC_TYPE _type;
+        };
+
+    } /* namespace MinMaxMean */
+} /* namespace Statistic */
 } /* namespace AMDA */
  
 #endif /* MINMAXMEANSTATISTIC_HH_ */