source: trunk/c++_tools/classifier/KernelLookup.cc @ 658

// $Id$

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


#include <cassert>
#ifndef NDEBUG
#include <algorithm>
#endif 

namespace theplu {
namespace classifier {  

  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
    : DataLookup2D(), kernel_(&kernel)
  {
    if (own)
      ref_count_ = new u_int(1);

    column_index_.reserve(kernel.size());
    for(size_t i=0; i<kernel.size(); i++)
      column_index_.push_back(i);
    row_index_=column_index_;
  }
  
  KernelLookup::KernelLookup(const Kernel& kernel,
                             const std::vector<size_t>& row, 
                             const std::vector<size_t>& column,
                             const bool owner)
    : DataLookup2D(row,column), kernel_(&kernel)
  {
    if (owner)
      ref_count_ = new u_int(1);

    // Checking that each row index is less than kernel.rows()
    assert(row.empty() || 
           *(std::max_element(row.begin(),row.end()))<kernel_->size());
    // Checking that each column index is less than kernel.column()
    assert(column.empty() || 
           *(std::max_element(column.begin(),column.end()))<kernel_->size());

  }


  KernelLookup::KernelLookup(const KernelLookup& other, 
                             const std::vector<size_t>& row, 
                             const std::vector<size_t>& column)
    : DataLookup2D(other,row,column), kernel_(other.kernel_)
  {
    ref_count_=other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
  }
  

  KernelLookup::KernelLookup(const KernelLookup& other)
    : DataLookup2D(other), kernel_(other.kernel_)
  {
    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<
           kernel_->size());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           kernel_->size());
    ref_count_=other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);

  }
  

  KernelLookup::KernelLookup(const KernelLookup& other, 
                             const std::vector<size_t>& index, 
                             const bool row)
    : DataLookup2D(other,index,row), kernel_(other.kernel_)
  {
    // Checking that no index is out of range
    assert(row_index_.empty() || 
           *(max_element(row_index_.begin(), row_index_.end()))<
           kernel_->size());
    assert(column_index_.empty() || 
           *(max_element(column_index_.begin(), column_index_.end()))<
           kernel_->size());
    ref_count_=other.ref_count_;
    if (ref_count_)
      ++(*ref_count_);
  }
  

  KernelLookup::~KernelLookup(void)
  {
    if (ref_count_)
      if (!--(*ref_count_))
        delete kernel_;
  }

  const KernelLookup* 
  KernelLookup::training_data(const std::vector<size_t>& train) const
  { 
    return new KernelLookup(*this,train,train); 
  } 


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


  const KernelLookup* 
  KernelLookup::selected(const std::vector<size_t>& inputs) const
  {
    const Kernel* kernel = kernel_->selected(inputs);
    return new KernelLookup(*kernel, row_index_, column_index_, true);
  }


  const KernelLookup* KernelLookup::test_kernel(const MatrixLookup& data) const
  {
    assert(data.rows()==kernel_->data().rows());
    if (!weighted()){
      utility::matrix* data_all = 
        new utility::matrix(data.rows(), rows()+data.columns());
      for (size_t i=0; i<data.rows(); ++i){
        // first columns are equal to data in kernel_
        for (size_t j=0; j<row_index_.size(); ++j)
          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
        // last columns are equal to new data
        for (size_t j=0;j<data.columns(); ++j)
          (*data_all)(i,j+row_index_.size()) = data(i,j);
      }
      std::vector<size_t> column_index;
      column_index.reserve(data.columns());
      for (size_t i=0;i<data.columns(); ++i)
        column_index.push_back(i+row_index_.size());
      const Kernel* kernel = 
        kernel_->make_kernel(MatrixLookup(*data_all, true), true);
      return new KernelLookup(*kernel, row_index_, column_index, true);
    }

    // kernel_ holds MatrixLookupWeighted, hence new Kernel also
    // should hold a MatrixLookupweighted.
    utility::matrix* data_all = 
      new utility::matrix(data.rows(), rows()+data.columns());
    utility::matrix* weight_all = 
      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);
    const MatrixLookupWeighted& kernel_data = 
      dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());

    for (size_t i=0; i<data.rows(); ++i){
      // first columns are equal to data in kernel_
      for (size_t j=0; j<row_index_.size(); ++j){
        (*data_all)(i,j) = kernel_data.data(i,row_index_[j]);
        (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
      }
      // last columns are equal to new data
      for (size_t j=0;j<data.columns(); ++j){
        (*data_all)(i,j+row_index_.size()) = data(i,j);
      }
    }
    std::vector<size_t> column_index;
    column_index.reserve(data.columns());
    for (size_t i=0;i<data.columns(); ++i)
      column_index.push_back(i+row_index_.size());
    const Kernel* kernel = 
      kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
    return new KernelLookup(*kernel, row_index_, column_index, true);
  }



  const KernelLookup* 
  KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
  {
    utility::matrix* data_all = 
      new utility::matrix(data.rows(), rows()+data.columns());
    utility::matrix* weight_all = 
      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);

    if (weighted()){
      const MatrixLookupWeighted& kernel_data = 
        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
    
      for (size_t i=0; i<data.rows(); ++i){
        // first columns are equal to data in kernel_
        for (size_t j=0; j<row_index_.size(); ++j){
          (*data_all)(i,j) = kernel_data.data(i,row_index_[j]);
          (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
        }
      }
    }
    else {

        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
    
      for (size_t i=0; i<data.rows(); ++i){
        // first columns are equal to data in kernel_
        for (size_t j=0; j<row_index_.size(); ++j)
          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
      }
    }

    // last columns are equal to new data
    for (size_t i=0; i<data.rows(); ++i){
      for (size_t j=0;j<data.columns(); ++j){
        (*data_all)(i,j+row_index_.size()) = data.data(i,j);
        (*weight_all)(i,j+row_index_.size()) = data.weight(i,j);
      }
    }
    
    std::vector<size_t> column_index;
    column_index.reserve(data.columns());
    for (size_t i=0;i<data.columns(); ++i)
      column_index.push_back(i+row_index_.size());
    const Kernel* kernel = 
      kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
    return new KernelLookup(*kernel, row_index_, column_index, true);
  }

}} // of namespace classifier and namespace theplu