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

// $Id$

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


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

namespace theplu {
namespace classifier {  

  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
    : DataLookup2D(own), kernel_(&kernel)
  {
    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,owner), kernel_(&kernel)
  {
    // 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& kernel, 
                             const std::vector<size_t>& row, 
                             const std::vector<size_t>& column)
    : DataLookup2D(kernel,row,column), kernel_(kernel.kernel_)
  {
  }
  

  KernelLookup::KernelLookup(const KernelLookup& kernel)
    : DataLookup2D(kernel), kernel_(kernel.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());

  }
  

  KernelLookup::KernelLookup(const KernelLookup& kl, 
                             const std::vector<size_t>& index, 
                             const bool row)
    : DataLookup2D(kl,index,row), kernel_(kl.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());

  }
  

  KernelLookup::~KernelLookup(void)
  {
    if (owner_)
      delete kernel_;
  }

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


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


  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::validation_data(const std::vector<size_t>& features, 
                                const std::vector<size_t>& train, 
                                const std::vector<size_t>& validation) const
  { 
    const Kernel* kernel = kernel_->selected(features);
    return new KernelLookup(*kernel, train, validation, true);
  } 


  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);
  }

}} // of namespace classifier and namespace theplu