source: trunk/lib/classifier/Kernel_MEV.h @ 545

// $Id: Kernel_MEV.h 545 2006-03-06 13:35:45Z peter $

#ifndef _theplu_classifier_kernel_mev_
#define _theplu_classifier_kernel_mev_

#include <c++_tools/classifier/DataLookup1D.h>
#include <c++_tools/classifier/Kernel.h>
#include <c++_tools/classifier/KernelFunction.h>
#include <c++_tools/gslapi/vector.h>
#include <c++_tools/gslapi/matrix.h>

namespace theplu {
namespace classifier {

  ///
  ///   @brief Memory Efficient Kernel
  ///   Class taking care of the \f$NxN\f$ kernel matrix, where
  ///   \f$N\f$ is number of samples. Type of Kernel is defined by a
  ///   KernelFunction. This Memory Efficient Version (MEV) does not
  ///   store the kernel matrix in memory, but calculates each element
  ///   when it is needed. When memory allows do always use Kernel_SEV
  ///   instead.
  ///   
  ///   @see also Kernel_SEV
  ///
  class Kernel_MEV : public Kernel 
  {
    
  public:
    
    ///
    ///   Constructor taking the data matrix and KernelFunction as
    ///   input.Each column in the data matrix corresponds to one
    ///   sample. @note Can not handle NaNs. 
    ///
    inline Kernel_MEV(const MatrixLookup& data, const KernelFunction& kf)
      : Kernel(data,kf) {}

    ///
    /// @todo doc
    ///
    Kernel_MEV(const Kernel_MEV& kernel, const std::vector<size_t>& index);


    ///
    ///   Destructor
    ///
    inline virtual ~Kernel_MEV(void) {};

    ///
    /// @return Element at position (\a row, \a column) of the Kernel
    /// matrix
    ///
    double operator()(const size_t row, const size_t column) const;
    
    ///
    /// @return kernel element between data @a ve and training sample @a i
    ///
    inline double element(const DataLookup1D& vec, const size_t i) const
    { return kf_->operator()(vec, DataLookup1D(*data_,i)); }
      
    inline double element(const DataLookup1D& vec, const DataLookup1D& w, 
                          const size_t i) const
    {return (*kf_)(vec, DataLookup1D(*data_,i), w, DataLookup1D(w.size(),1.0));}

    const Kernel_MEV* selected(const std::vector<size_t>& index) const;

    inline bool weighted(void) const { return false; }

  private:
    ///
    /// Copy constructor (not implemented)
    ///
    Kernel_MEV(const Kernel_MEV&);

  }; // class Kernel_MEV

}} // of namespace classifier and namespace theplu

#endif