source: trunk/c++_tools/statistics/Score.h @ 623

#ifndef _theplu_statistics_score_
#define _theplu_statistics_score_

// $Id: Score.h 623 2006-09-05 02:13:12Z peter $

#include <c++_tools/classifier/utility.h>
#include <c++_tools/utility/vector.h>

#include <cassert>
#ifndef NDEGUG
#include <c++_tools/classifier/Target.h>
#include <c++_tools/classifier/DataLookup1D.h>
#endif

namespace theplu {
namespace classifier {
  class Target;
  class DataLookup1D;
  class DataLookupWeighted1D;
}

namespace statistics {

  ///
  /// Abstract Base Class defining the interface for the score classes.
  ///
  class Score 
  {

  public:
    ///
    ///   Constructor
    ///    
    Score(bool absolute=true) ;
    
    ///
    ///   Destructor
    ///
    virtual ~Score(void) {};
    
    ///
    ///  Function changing mode of Score
    ///
    inline void absolute(bool absolute) {absolute_=absolute;}

    ///
    /// Function calculating the score. In absolute mode, also the
    /// score using negated class labels is calculated, and the
    /// largest of the two scores are calculated. Absolute mode should
    /// be used when two-tailed test is wanted.
    ///
    virtual double 
    score(const classifier::Target& target, 
          const utility::vector& value) = 0; 
 
    ///
    /// Function calculating the score. In absolute mode, also the
    /// score using negated class labels is calculated, and the
    /// largest of the two scores are calculated. Absolute mode should
    /// be used when two-tailed test is wanted.
    ///
    /// @return statistica.
    ///
    /// @param target vector of targets (most often +1 -1)
    /// @param value vector of the values
    /// 
    inline double 
    score(const classifier::Target& target, 
          const classifier::DataLookup1D& value) 
    { 
      assert(target.size()==value.size()); 
      utility::vector a;
      classifier::convert(value,a);
      return score(target,a); 
    }
 
    ///
    /// Function calculating the score in a weighted fashion. In
    /// absolute mode, also the score using negated class labels is
    /// calculated, and the largest of the two scores are
    /// calculated. Absolute mode should be used when two-tailed test
    /// is wanted.
    ///
    virtual double 
    score(const classifier::Target& target, 
          const classifier::DataLookupWeighted1D& value) = 0; 
 
    ///
    /// Function calculating the weighted version of score. In
    /// absolute mode, also the score using negated class labels is
    /// calculated, and the largest of the two scores are
    /// calculated. Absolute mode should be used when two-tailed test
    /// is wanted.
    ///
    virtual double 
    score(const classifier::Target& target, 
          const utility::vector& value,
          const utility::vector& weight) = 0; 

    ///
    /// Function calculating the weighted version of score. In
    /// absolute mode, also the score using negated class labels is
    /// calculated, and the largest of the two scores are
    /// calculated. Absolute mode should be used when two-tailed test
    /// is wanted.
    ///
    inline double 
    score(const classifier::Target& target, 
          const classifier::DataLookup1D& value,
          const classifier::DataLookup1D& weight) 
    { 
      utility::vector a;
      classifier::convert(value,a);
      utility::vector b;
      classifier::convert(weight,a);
      return score(target,a,b); 
    }

  protected:
    inline bool weighted(void) const { return weighted_; }

    bool absolute_;
    bool weighted_;

  }; // class Score

}} // of namespace statistics and namespace theplu

#endif