source: trunk/c++_tools/classifier/MatrixLookupWeighted.cc @ 624

// $Id$

#include <c++_tools/classifier/MatrixLookupWeighted.h>

#include <c++_tools/utility/matrix.h>

#ifndef NDEBUG
#include <algorithm>
#endif 

#include <fstream>

namespace theplu {
namespace classifier {

  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights)
    : DataLookup2D(), data_(&data), weights_(&weights)
  {
    assert(data.rows()==weights.rows());
    assert(data.columns()==weights.columns());
    for(size_t i=0;i<(*data_).rows();i++)
      row_index_.push_back(i);
    for(size_t i=0;i<(*data_).columns();i++)
      column_index_.push_back(i);
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights, 
                                             const std::vector<size_t>& row, 
                                             const std::vector<size_t>& col)
    : DataLookup2D(row,col), data_(&data), weights_(&weights)
  {
    // Checking that each row index is less than data.rows()
    assert(row.empty() || 
           *(std::max_element(row.begin(),row.end()))<data.rows());
    // Checking that each column index is less than data.column()
    assert(col.empty() || 
           *(std::max_element(col.begin(),col.end()))<data.columns());
    // Checking that each row index is less than weights.rows()
    assert(row.empty() || 
           *(std::max_element(row.begin(),row.end()))<weights.rows());
    // Checking that each column index is less than weights.column()
    assert(col.empty() || 
           *(std::max_element(col.begin(),col.end()))<weights.columns());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
                                             const utility::matrix& weights, 
                                             const std::vector<size_t>& index, 
                                             const bool row)
    : DataLookup2D(), data_(&data), weights_(&weights)
  {
    if (row){
      // Checking that each row index is less than data.rows()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<data.rows());
      // Checking that each row index is less than weights.rows()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<weights.rows());
      row_index_=index;
      assert(column_index_.empty());
      column_index_.reserve(data.columns());
      for (size_t i=0; i<data.columns(); i++)
        column_index_.push_back(i);
    }
    else{
      // Checking that each column index is less than data.column()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<data.columns());
      // Checking that each column index is less than weights.column()
      assert(index.empty() || 
             *(std::max_element(index.begin(),index.end()))<weights.columns());
      column_index_=index;
      assert(row_index_.empty());
      column_index_.reserve(data.rows());
      for (size_t i=0; i<data.rows(); i++)
        row_index_.push_back(i);
    }
  }
  

  /*
  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& dv,
                                             const MatrixLookup& wv)
    : DataLookup2D(dv), data_(dv.data_), weights_(dv.data_)
  {
  }
  */


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& dv)
    : DataLookup2D(dv), data_(dv.data_), weights_(dv.weights_)
  {
  }



  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& ml, 
                                             const std::vector<size_t>& row, 
                                             const std::vector<size_t>& col)
    : DataLookup2D(ml,row,col), data_(ml.data_), weights_(ml.weights_)
  {
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& ml, 
                                             const std::vector<size_t>& index, 
                                             bool row)
    : DataLookup2D(ml,index,row), data_(ml.data_), weights_(ml.weights_)
  {
    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<data_->rows());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           data_->columns());
    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<
           weights_->rows());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           weights_->columns());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const size_t rows, 
                                             const size_t columns, 
                                             const double value,
                                             const double weight)
    : DataLookup2D(rows,columns, true) 
  {
    data_ = new utility::matrix(1,1,value);
    weights_ = new utility::matrix(1,1,weight);
  }

  
    MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
    : DataLookup2D(true)
  {
    data_ = new utility::matrix(is,sep);
    for(size_t i=0;i<(*data_).rows();i++)
      row_index_.push_back(i);
    for(size_t i=0;i<(*data_).columns();i++)
      column_index_.push_back(i);
    utility::matrix weights;
    data_->nan(weights);    
    weights_= new utility::matrix(weights);
  }
  

  MatrixLookupWeighted::~MatrixLookupWeighted(void)
  {
    if (owner_){
      delete data_;
      delete weights_;
    }
  }


  const MatrixLookupWeighted* 
  MatrixLookupWeighted::selected(const std::vector<size_t>& i) const
  { 
    return new MatrixLookupWeighted(*this,i, true); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::training_data(const std::vector<size_t>& i) const
  { 
    return new MatrixLookupWeighted(*this,i, false); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::training_data(const std::vector<size_t>& features,
                                      const std::vector<size_t>& samples) const
  { 
    return new MatrixLookupWeighted(*this,features, samples); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::validation_data(const std::vector<size_t>& train,
                                        const std::vector<size_t>& val) const
  { 
    return new MatrixLookupWeighted(*this,val, false); 
  }



  const MatrixLookupWeighted* 
  MatrixLookupWeighted::validation_data(const std::vector<size_t>& features,
                                        const std::vector<size_t>& training,
                                        const std::vector<size_t>& val) const
  { 
    return new MatrixLookupWeighted(*this,features, val); 
  }



  const MatrixLookupWeighted& MatrixLookupWeighted::operator=
  (const MatrixLookupWeighted& other)
  {
    if (this!=&other){
      if (owner_){
        delete data_;
        delete weights_;
        owner_=false;
      }
      DataLookup2D::operator=(other);
      data_ = other.data_;
      weights_ = other.weights_;
    }
    return *this;
  }


  std::ostream& operator<<(std::ostream& s, const MatrixLookupWeighted& m)
  {
    s.setf(std::ios::dec);
    s.precision(12);
    for(size_t i=0, j=0; i<m.rows(); i++)
      for (j=0; j<m.columns(); j++) {
        s << m(i,j);
        if (j<m.columns()-1)
          s << s.fill();
        else if (i<m.rows()-1)
          s << "\n";
      }
    return s;
  }



}} // of namespace classifier and namespace theplu