PursuitStats.hpp

Go to the documentation of this file.

#ifndef LGL_PURSUIT_STATS_HPP
#define LGL_PURSUIT_STATS_HPP

#include <lgl/Stats.hpp>
#include <lgl/PursuitGraph.hpp>

#include <ostream>

namespace jafar {
  namespace lgl {
    
    class PursuitStats {
    
      private :
        // nbr of rounds in the game
        unsigned int rounds ;

        // horizon
        Stats< unsigned int> horizon ;

        // computation time
        Stats< double > computationTime ;

        // number of front nodes 
        Stats< unsigned int > front ;

        // number of risk nodes 
        Stats< unsigned int > risk ;

        // number of danger nodes 
        Stats< unsigned int > danger ;

        // Ratio for the risk level of the root
        unsigned int cntOK ;
        unsigned int cntRISK ;
        unsigned int cntDANGER ;

        double rateOK  ;
        double rateRISK ;
        double rateDANGER ;


      public : 
        PursuitStats() : rounds(0)
        { 
          cntOK     = 0 ;
          cntRISK   = 0 ;
          cntDANGER = 0 ;
        }

        ~PursuitStats() 
        { }
      
        void update ( const PursuitGraph *myPG , double _computationTime)
        {
          rounds ++;

          // update the statistics values
          horizon.update( myPG->gethorizon() );

          computationTime.update( _computationTime );

          front.update( myPG->getfront().size() );
          risk.update( myPG->getrisk().size() );
          danger.update( myPG->getdanger().size() );

          // update ratio
          switch ( myPG->getroot()->risk )
          {
            case SEEN       :     cntOK++ ;     break;
            case RISK       :   cntRISK++ ;   break;
            case DANGER_HIDDEN  : 
            case DANGER_UNSEEN  : 
            case DANGER_LOST  : 
            case DANGER_DISAPPEARED :   cntDANGER++ ;   break;
            default :   ; // Throw exception ?
          }

          rateOK    = ( cntOK     / double(rounds) ) ;   
          rateRISK  = ( cntRISK   / double(rounds) ) ;
          rateDANGER  = ( cntDANGER / double(rounds) ) ;

        }
         
        void reset()
        {
    
          rounds    = 0 ;
    
          cntOK     = 0 ;
          cntRISK   = 0 ;
          cntDANGER   = 0 ;
    
        }

        unsigned int getrounds()            const { return (rounds);      }

        const Stats< unsigned int> * gethorizon()     const { return (&horizon);    }   
        const Stats< double > * getcomputationTime()  const { return (&computationTime);}

        const Stats< unsigned int > * getfront()    const { return (&front);      }
        const Stats< unsigned int > * getrisk()     const { return (&risk);     }
        const Stats< unsigned int > * getdanger()     const { return (&danger);     }

        unsigned int getcntOK()             const { return(cntOK);      }
        unsigned int getcntRISK()             const { return(cntRISK);      }
        unsigned int getcntDANGER()           const { return(cntDANGER);    }

        double getrateOK()                const { return(rateOK);     }
        double getrateRISK()              const { return(rateRISK);     }
        double getrateDANGER()              const { return(rateDANGER);   }
        
    };

    /* output stream for PursuitGNode */
    std::ostream& operator<<(std::ostream& out, PursuitStats const &rhs);

  }
}

#endif /* LGL_PURSUIT_STATS_HPP */