source: trunk/c++_tools/utility/WeNNI.cc @ 675

// $Id: WeNNI.cc 675 2006-10-10 12:08:45Z jari $

/*
  Copyright (C) 2004 Jari Häkkinen
  Copyright (C) 2005 Jari Häkkinen, Peter Johansson
  Copyright (C) 2006 Jari Häkkinen

  This file is part of the yat library, http://lev.thep.lu.se/trac/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 "yat/utility/WeNNI.h"

#include "yat/utility/matrix.h"
#include "yat/utility/stl_utility.h"

#include <algorithm>
#include <cmath>
#include <fstream>

namespace theplu {
namespace utility {


  WeNNI::WeNNI(const utility::matrix& matrix,const utility::matrix& flag,
               const u_int neighbours)
    : NNI(matrix,flag,neighbours), imputed_data_raw_(matrix)
  {
    //estimate();
  }



  // \hat{x_{ij}}=\frac{ \sum_{k=1,N} \frac{w_{kj}*x_{kj}}{d_{ki}} }
  //                   { \sum_{k=1,N} \frac{w_{kj}       }{d_{ki}} }
  // where N is defined in the paper cited in the NNI class definition
  // documentation.
  u_int WeNNI::estimate(void)
  {
    for (unsigned int i=0; i<data_.rows(); i++) {
      // Jari, avoid copying in next line
      std::vector<std::pair<u_int,double> > distance=calculate_distances(i);
      std::sort(distance.begin(),distance.end(),
                pair_value_compare<u_int,double>());
      bool row_imputed=true;
      for (unsigned int j=0; j<data_.columns(); j++) {
        std::vector<u_int> knn=nearest_neighbours(j,distance);
        double new_value=0.0;
        double norm=0.0;
        for (std::vector<u_int>::const_iterator k=knn.begin(); k!=knn.end();
             ++k) {
          // Jari, a small number needed here, use something standardized.
          // Avoid division with zero (perfect match vectors)
          double d=(distance[*k].second ? distance[*k].second : 1e-10);
          new_value+=(weight_(distance[*k].first,j) *
                      data_(distance[*k].first,j)/d);
          norm+=weight_(distance[*k].first,j)/d;
        }
        // No impute if no contributions from neighbours.
        if (norm){
          imputed_data_raw_(i,j) = new_value/norm;
          imputed_data_(i,j)=
            weight_(i,j)*data_(i,j) + (1-weight_(i,j))* imputed_data_raw_(i,j);
        }
        else
          row_imputed=false;
      }
      if (!row_imputed)
        not_imputed_.push_back(i);
    }
    return not_imputed_.size();
  }


}} // of namespace utility and namespace theplu