source: branches/0.4-stable/yat/classifier/IGP.h @ 1392

#ifndef _theplu_yat_classifier_igp_ 
#define _theplu_yat_classifier_igp_ 

// $Id$

/*
  Copyright (C) 2006, 2007 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2008 Peter Johansson, Markus Ringnér

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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 2 of the
  License, or (at your option) any later version.

  The yat library 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, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "DataLookup1D.h"
#include "MatrixLookup.h"
#include "Target.h"
#include "yat/utility/Vector.h"
#include "yat/utility/yat_assert.h"

#include <cmath>
#include <limits>
#include <stdexcept>

namespace theplu {
namespace yat {
namespace classifier {  

  class Target;
  class MatrixLookup;

  ///
  /// @brief Class for In Group Proportions (IGP)
  /// See Kapp and Tibshirani, Biostatistics (2006).
  ///
  template <typename Distance>
  class IGP
  {
  
  public:
    ///
    /// Constructor taking the training data and the target vector and
    /// as input. 
    ///
    IGP(const MatrixLookup&, const Target&);


    ///
    /// Constructor taking the training data, the target vector and
    /// the distance measure as input. 
    ///
    IGP(const MatrixLookup&, const Target&, const Distance&);

    ///
    /// Destrucutor
    ///
    virtual ~IGP();

    ///
    /// @return the IGP score for each class as elements in a vector.
    ///
    const utility::Vector& score(void) const;


  private:
    void calculate();

    utility::Vector igp_;
    Distance distance_;

    const MatrixLookup& matrix_;
    const Target& target_;
  };  

  
  // templates

  template <typename Distance>
  IGP<Distance>::IGP(const MatrixLookup& data, const Target& target) 
    : matrix_(data), target_(target)
  {   
    calculate();
  }

  template <typename Distance>
  IGP<Distance>::IGP(const MatrixLookup& data, const Target& target, const Distance& dist) 
    : matrix_(data), target_(target), distance_(dist)
  {   
    calculate();
  }

  
  template <typename Distance>
  IGP<Distance>::~IGP()   
  {
  }

  template <typename Distance>
  void IGP<Distance>::calculate() 
  {
    utility::yat_assert<std::runtime_error>(target_.size()==matrix_.columns());
    
    // Calculate IGP for each class
    igp_ = utility::Vector(target_.nof_classes());
    
    for(size_t i=0; i<target_.size(); i++) {
      size_t neighbor=i;
      double mindist=std::numeric_limits<double>::max();
      const DataLookup1D a(matrix_,i,false);
      for(size_t j=0; j<target_.size(); j++) {            
        DataLookup1D b(matrix_,j,false);
        double dist=distance_(a.begin, a.end(), b.begin());
        if(j!=i && dist<mindist) {
          mindist=dist;
          neighbor=j;
        }
      }
      if(target_(i)==target_(neighbor))
        igp_(target_(i))++;
      
    }
    for(size_t i=0; i<target_.nof_classes(); i++) {
      igp_(i)/=static_cast<double>(target_.size(i));
    }
  }

  
  template <typename Distance>
  const utility::Vector& IGP<Distance>::score(void) const 
  {
    return igp_;
  }
  
}}} // of namespace classifier, yat, and theplu

#endif