Stat.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _GranOO_LibMath_Stat_hpp_
#define _GranOO_LibMath_Stat_hpp_
 
#include <vector>
#include <cmath>
#include <limits>
#include <complex>
 
#include "GranOO3/Core/Macro.hpp"
 
namespace GranOO3
{
  namespace Math
  {
 
 
 
    class Stat
    {
    public:
      template<typename T> static void All(const T&, double & ave, double & std, double & min, double & max);
      template<typename T> static void AverageStdDev(const T&, double & ave, double & std);
      template<typename T> static double Average(const T&);
      template<typename T> static double StdDev(const T&);
      template<typename T> static double Max(const T&);
      template<typename T> static double Min(const T&);
      template<typename T> static double Sum(const T&);
 
    public:
      Stat();
      ~Stat();
      Stat(const Stat&);
      Stat & operator=(const Stat &);
 
      GRANOO_ACCESS(value, std::vector<double>, _value);
      GRANOO_ACCESS(average, double, _ave);
      GRANOO_ACCESS(std, double, _std);
      GRANOO_ACCESS(min, double, _min);
      GRANOO_ACCESS(max, double, _max);
 
      void update();
      size_t Size() const;
      void add(double);
      void clear();
 
    private:
      std::vector<double> _value;
      double _ave;
      double _std;
      double _min;
      double _max;
    };
 
    std::ostream& operator<< (std::ostream& os, const Stat& v);
 
 
    template<typename T>
    inline void
    Stat::All(const T& container, double & ave, double & std, double & min, double & max) {
      ave = Average(container);
      std = 0.;
      max = std::numeric_limits<double>::min();
      min = std::numeric_limits<double>::max();
 
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        std += pow(*it - ave, 2);
        if (*it > max)
          max = *it;
        if (*it <  min)
          min = *it;
      }
      std = sqrt(std/double(container.size()));
    }
 
    template<typename T>
    inline double
    Stat::Average(const T& container) {
      double val = 0.;
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it)
        val += (*it);
      val /= double(container.size());
      return val;
    }
 
    template<typename T>
    inline double
    Stat::StdDev(const T& container) {
      const double average = Average(container);
      double val = 0;
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it)
        val += pow(*it - average, 2);
      val = sqrt(val/double(container.size()));
      return val;
    }
 
    template<typename T>
    void
    Stat::AverageStdDev(const T& container, double& average, double& stdDev) {
      average = Average(container);
      stdDev = 0;
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it)
        stdDev += pow(*it - average, 2);
      stdDev = sqrt(stdDev/double(container.size()));
    }
 
    template<typename T>
    inline double
    Stat::Max(const T& container) {
      double val = std::numeric_limits<double>::min();
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        if (*it > val)
          val = *it;
      }
      return val;
    }
 
    template<typename T>
    inline double
    Stat::Min(const T& container) {
      double val = std::numeric_limits<double>::max();
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it) {
        if (*it <  val)
          val = *it;
      }
      return val;
    }
 
    template<typename T>
    inline double
    Stat::Sum(const T& container) {
      double val = 0.;
      typename T::const_iterator it;
      for (it = container.begin(); it != container.end(); ++it)
        val += *it;
 
      return val;
    }
 
  }
}
#endif