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

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

#ifndef _theplu_classifier_kernel_weighted_sev_
#define _theplu_classifier_kernel_weighted_sev_

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


namespace theplu {
namespace classifier {

  class KernelFunction;

  ///
  ///   @brief Speed 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 Speed Efficient Version (SEV) calculated
  ///   the kernel matrix once and the kernel is stored in
  ///   memory. When \f$N\f$ is large and the kernel matrix cannot be
  ///   stored in memory, use Kernel_MEV instead.
  ///   
  ///   @see also Kernel_MEV
  ///
  class KernelWeighted_SEV : public Kernel 
  {
    
  public:

    ///
    ///   Constructor taking the data matrix and KernelFunction as
    ///   input. @note Can not handle NaNs. When dealing with missing values,
    ///   use constructor taking a weight matrix.
    ///
    /// @note if @a data, @a kf, or @a weights is destroyed the
    /// behaviour of the object is undefined
    ///
    KernelWeighted_SEV(const MatrixLookup& data, const KernelFunction& kf, 
                       const MatrixLookup& weights);

    ///
    /// @todo doc
    ///
    KernelWeighted_SEV(const KernelWeighted_SEV& other, 
                       const std::vector<size_t>& index);
    
    ///
    /// @return element at position (\a row, \a column) in the Kernel
    /// matrix
    ///
    inline double operator()(const size_t row,const size_t column) const
    { return kernel_matrix_(row,column); }

    ///
    /// @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_)(vec, DataLookup1D(*data_,i), 
                    DataLookup1D(vec.size(),1.0),
                    DataLookup1D(*weights_,i)); 
    }

    inline double element(const DataLookup1D& vec, const DataLookup1D& w, 
                          const size_t i) const
    { 
      return (*kf_)(vec, DataLookup1D(*data_,i),w,DataLookup1D(*weights_,i)); 
    }

    ///
    /// @todo doc
    ///
    const KernelWeighted_SEV* selected(const std::vector<size_t>& index) const;

    ///
    /// @return true
    ///
    inline bool weighted(void) const { return true; }

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

    gslapi::matrix kernel_matrix_;

  }; // class Kernel_SEV

}} // of namespace classifier and namespace theplu

#endif