source: trunk/src/ROC.h @ 148

// $Id: ROC.h 148 2004-09-09 13:22:41Z peter $

#ifndef _theplu_cpptools_roc_ 
#define _theplu_cpptools_roc_ 

// C++ tools include
/////////////////////
#include "Score.h"
#include "vector.h"

// Standard C++ includes
////////////////////////
#include <utility>
#include <vector>

namespace theplu {
namespace cpptools {  
  ///
  /// Class for ROC (Reciever Operating Characteristic). 
  ///   
  
  class ROC : public Score
  {
  
  public:
    ///
    /// Default constructor
    ///
    ROC();
         
    ///
    /// Destructor 
    ///
    virtual ~ROC(void) {};
         
    /// Function taking \a value, \a target (+1 or -1) and vector
    /// defining what samples to use. The score is equivalent to
    /// Mann-Whitney statistics @return the area under the ROC
    /// curve. If the area is less than 0.5, is 1-area returned.
    ///
    double score(const gslapi::vector& value, const gslapi::vector& target, 
                 const std::vector<size_t>& = std::vector<size_t>());
    
    /// Function taking values, target, weight and a vector defining
    /// what samples to use. The area is defines as \f$ \frac{\sum
    /// w^+w^-}{\sum w^+w^-}\f$, where the sum in the numerator goes
    /// over all pairs where value+ is larger than value-. The
    /// denominator goes over all pairs. @return wheighted version of
    /// area under the ROC curve. If the area is less than 0.5, is
    /// 1-area returned.
    ///
    double score(const gslapi::vector&, const gslapi::vector&,
                 const gslapi::vector&,   
                 const std::vector<size_t>& = std::vector<size_t>());
       
    ///
    ///Calculates the p-value, i.e. the probability of observing an area
    ///equally or larger if the null hypothesis is true. If P is near zero,
    ///this casts doubt on this hypothesis. The null hypothesis is that the
    ///values from the 2 classes are generated from 2 identical
    ///distributions. The alternative is that the median of the first
    ///distribution is shifted from the median of the second distribution by a
    ///non-zero amount. If the smallest group size is larger than minimum_size
    ///(default = 10), then P is calculated using a normal approximation.
    /// @return the one-sided p-value
    ///
    double p_value() ;
         
    ///
    /// @return the targets in train_set sorted with respect to the
    /// corresponding data
    ///
    gslapi::vector ROC::target(void) const;

    ///
    /// Changes minimum_size , i.e. the threshold when a normal
    /// approximation is used for the p-value calculation.
    ///
    inline void minimum_size(const u_int minimum_size) 
    {minimum_size_ = minimum_size; }  

  private:
    double area_;
    gslapi::vector data_;
    u_int minimum_size_;
    u_int nof_pos_;
    gslapi::vector target_;
    std::vector<size_t> train_set_; 
    std::vector<std::pair<double, double> > value_; 
    /// pair of target and data. should always be sorted with respect to
    /// data. 
    gslapi::vector weight_;
    
    ///
    ///
    /// Implemented as in MatLab 13.1
    /// @return the p-value
    ///
    double ROC::get_p_approx(const double) const;
    
    ///
    /// @return the p-value
    ///
    double ROC::get_p_exact(const double, const double, 
                            const double);
  
    ///
    /// sorting value_, should always be done when changing train_set_
    ///
    void ROC::sort();
        
  };

  ///
  /// The output operator for the ROC class. The output is an Nx2
  /// matrix, where the first column is the sensitivity and second
  /// is the specificity.
  ///
  std::ostream& operator<< (std::ostream& s, const ROC&);


}} // of namespace cpptools and namespace theplu

#endif