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

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

#ifndef _theplu_classifier_kernel_
#define _theplu_classifier_kernel_

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

#include <cctype>
#include <vector>

namespace theplu {
namespace classifier {

  ///
  ///   @brief Base Class for Kernels. 
  ///
  ///   Class taking care of the \f$NxN\f$ kernel matrix, where
  ///   \f$N\f$ is number of samples. Each element in the Kernel
  ///   matrix is the scalar product of the corresponding pair of
  ///   samples. Type of Kernel is defined by a KernelFunction.
  ///   
  ///   @note If the KernelFunction is destroyed, the Kernel is no
  ///   longer defined.
  ///
  class 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. 
    ///
    Kernel(const MatrixLookup& data, const KernelFunction& kf); 

    Kernel(const MatrixLookup& data, const KernelFunction& kf, 
           const MatrixLookup& weight); 
    
    ///
    /// @todo doc
    ///
    Kernel(const Kernel& kernel, const std::vector<size_t>& index);

    ///
    ///   Destructor
    ///
    virtual ~Kernel(void);

    ///
    /// @return element at position (\a row, \a column) of the Kernel
    /// matrix
    ///
    virtual double operator()(const size_t row, const size_t column) const=0;

    ///
    /// @return number columns in Kernel
    ///
    inline size_t columns(void) const { return size(); } 

    inline const MatrixLookup& data(void) const { return *data_; }

    ///
    /// @return number of rows in Kernel
    ///
    inline size_t rows(void) const { return size(); } 

    ///
    /// @brief number of samples
    ///
    inline size_t size(void) const { return data_->columns(); } 

    
    virtual double element(const DataLookup1D& vec, const size_t i) const=0;
    virtual double element(const DataLookup1D& vec, const DataLookup1D& w,
                           const size_t i) const=0;

    ///
    /// Created Kernel is built from selected features in data. The
    /// @a index corresponds to which rows in data to use for the
    /// calculation of the returned Kernel.
    /// 
    /// @return Dynamically allocated Kernel based on selected features
    ///
    /// @Note Returns a dynamically allocated Kernel, which has
    /// to be deleted by the caller to avoid memory leaks.
    ///
    virtual const Kernel* selected(const std::vector<size_t>& index) const=0;

    ///
    /// @return true if kernel is calculated using weights
    ///
    virtual bool weighted(void) const=0;

    inline const MatrixLookup& weights(void) const { return *weights_; }

  protected:
    const MatrixLookup* data_;
    const MatrixLookup* weights_;
    const KernelFunction* kf_;
    const bool data_owner_;
    const bool weight_owner_;

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


  }; // class Kernel

}} // of namespace classifier and namespace theplu

#endif