bin.hh

Go to the documentation of this file.

// Copyright (c) 2014, LAAS-CNRS
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
//
// This file is part of hpp-statistics.
// hpp-statistics is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-statistics 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 Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-statistics. If not, see <http://www.gnu.org/licenses/>.

#ifndef HPP_STATISTICS_BIN_HH
# define HPP_STATISTICS_BIN_HH

# include <ostream>
# include <list>
# include <algorithm>

# include "hpp/statistics/config.hh"
# include "hpp/statistics/fwd.hh"

namespace hpp {
  namespace statistics {
    class HPP_STATISTICS_DLLAPI Bin
    {
      public:
        const std::size_t& freq () const
        {
          return freq_;
        }

        std::size_t operator ++()
        {
          return ++freq_;
        }

        std::size_t operator ++(int)
        {
          return freq_++;
        }

        virtual std::ostream& print (std::ostream& os) const
        {
          return printValue (os << freq () << " - ");
        }

        virtual std::ostream& printValue (std::ostream& os) const = 0;

      protected:
        Bin () : freq_ (0) {}

      private:
        std::size_t freq_;
    };

    inline std::ostream& operator<< (std::ostream& os, const hpp::statistics::Bin& b)
    {
      return b.print (os);
    }

    template < typename T >
    class HPP_STATISTICS_DLLAPI Statistics
    {
      public:
        typedef typename std::list < T > Container;
        typedef typename Container::iterator iterator;
        typedef typename Container::const_iterator const_iterator;

        virtual std::size_t freq (const T& bin) const;

        virtual Proba_t relativeFreq (const T& bin) const;

        std::size_t numberOfObservations () const
        {
          return counts_;
        }

        unsigned int numberOfBins () const
        {
          return bins_.size ();
        }

        virtual std::ostream& print (std::ostream& os) const;

        const_iterator find (const T& bin) const;

        template < typename U > const_iterator find (const U& value) const;

        const_iterator begin() const
        {
          return bins_.begin();
        }

        const_iterator end() const
        {
          return bins_.end();
        }

        void clear ()
        {
          bins_.clear();
        }

      protected:
        Statistics();

        virtual T& increment (const T& bin) __attribute__ ((deprecated));

        virtual iterator insert (const T& bin);

      private:
        Container bins_;

        std::size_t counts_;
    };

    template < typename T >
      std::ostream& operator<< (std::ostream& os, const hpp::statistics::Statistics <T>& ss);
  } // namespace statistics
} // namespace hpp


namespace hpp {
  namespace statistics {
    template < typename T >
      T& Statistics <T>::increment (const T& b)
    {
      counts_++;
      iterator it = bins_.begin ();
      for (; it != bins_.end (); it++) {
        if (! (*it < b)) {
          if (! (*it == b))
            it = bins_.insert (it, b);
          (*it)++;
          return *it;
        }
      }
      it = bins_.insert (it, b);
      (*it)++;
      return *it;
    }

    template < typename T >
      typename Statistics<T>::iterator Statistics <T>::insert (const T& b)
    {
      counts_++;
      iterator it = bins_.begin ();
      for (; it != bins_.end (); it++) {
        if (! (*it < b)) {
          if (! (*it == b))
            it = bins_.insert (it, b);
          (*it)++;
          return it;
        }
      }
      it = bins_.insert (it, b);
      (*it)++;
      return it;
    }

    template < typename T>
      typename Statistics<T>::const_iterator Statistics <T>::find (const T& b) const
    {
      for (const_iterator it = bins_.begin ();
          it != bins_.end (); it++) {
        if (*it < b)
          continue;
        if (*it == b)
          return it;
        break;
      }
      return bins_.end ();
    }

    template < typename T> template < typename U >
      typename Statistics<T>::const_iterator Statistics <T>::find (const U& v) const
    {
      return find (T (v));
    }

    template < typename T >
      size_t Statistics <T>::freq (const T& b) const
    {
      const_iterator it = std::find (bins_.begin (), bins_.end (), b);
      if (it == bins_.end ()) {
        return 0;
      }
      return it->freq ();
    }

    template < typename T >
      Proba_t Statistics <T>::relativeFreq (const T& b) const
    {
      const_iterator it = std::find (bins_.begin (), bins_.end (), b);
      if (it == bins_.end ()) {
        return 0;
      }
      return (Proba_t)it->freq () / (Proba_t)numberOfObservations();
    }

    template < typename T >
      Statistics <T>::Statistics () :bins_ (), counts_(0)
    {}

    template < typename T >
      std::ostream& Statistics<T>::print (std::ostream& os) const
    {
      const_iterator it;
      for (it = begin(); it != end(); it++) {
        it->print (os) << std::endl;
      }
      os << "Total number of observations: " << numberOfObservations ();
      return os;
    }

    template < typename T >
      std::ostream& operator<< (std::ostream& os, const hpp::statistics::Statistics <T>& ss)
      {
        return ss.print (os);
      }
  } // namespace statistics
} // namespace hpp

#endif // HPP_STATISTICS_BIN_HH