source: trunk/c++_tools/classifier/DataLookup2D.h @ 631

// $Id$

#ifndef _theplu_classifier_DataLookup2D_ 
#define _theplu_classifier_DataLookup2D_ 

#include <vector>
#include <iostream>

namespace theplu {
namespace classifier {  

  ///
  /// @brief Interface class for classifier data.
  ///
  /// This is the abstract base class defining a common interface for
  /// MatrixLookup and KernelLookup. The general idea o the Lookup
  /// classes is to: rather than copying the sub-matrix or sub-kernel,
  /// to hold a pointer to the underlying matrix/kernel and a vector
  /// of row indices and a vector of column indices. These indices
  /// then define what element to look into.
  ///
  /// This allow fast construction of sub-matrices/sub-kernels and at
  /// almost no extra memory usage.
  ///
  class DataLookup2D
  {
  
  public:
    
    ///
    /// Default constructor.
    ///
    inline DataLookup2D(const bool owner=false) : owner_(owner){};


    ///
    /// Constructor taking the @a row index vector and @a column index
    /// vector as input. If @a owner is set true, the object is
    /// consider as owner of the underlying data (and the data is
    /// deleted at destruction).
    ///
    DataLookup2D(const std::vector<size_t>& row, 
                 const std::vector<size_t>& column, 
                 const bool owner = false);

    ///
    /// @brief Copy constructor. Indices and pointer to underlying
    /// data is copied, whereas owner is set to false.
    ///
    DataLookup2D(const DataLookup2D&);

    ///
    /// Copy the index such that new(i,j) = old(row[i],col[j])
    ///
    DataLookup2D(const DataLookup2D&, const std::vector<size_t>& row, 
                 const std::vector<size_t>& col);

    ///
    /// If row is true indices are copied so new(i,j)=old(index[i],j).
    /// Else indices are copied so new(i,j)=old(i,index[j])
    ///
    DataLookup2D(const DataLookup2D&, const std::vector<size_t>& index, 
                 const bool row);


    ///
    /// Indices are created all pointing to the zero-zero element
    /// created in daughter classes.
    ///
    DataLookup2D(const size_t, const size_t, const bool owner);


    ///
    /// @brief Destructor
    ///
    virtual ~DataLookup2D() {};

    ///
    /// @return number of columns
    ///
    inline size_t columns(void) const { return column_index_.size(); } 

    ///
    ///
    ///
    virtual const DataLookup2D* selected(const std::vector< size_t > &) const=0;

    ///
    /// @return sub-Lookup of the DataLookup2D
    ///
    /// @Note Returns a dynamically allocated DataLookup2D, which has
    /// to be deleted by the caller to avoid memory leaks.
    ///
    virtual const DataLookup2D* 
    training_data(const std::vector<size_t>&) const=0; 

    ///
    /// @return sub-Lookup of the DataLookup2D
    ///
    /// @Note Returns a dynamically allocated DataLookup2D, which has
    /// to be deleted by the caller to avoid memory leaks.
    ///
    virtual const DataLookup2D* 
    training_data(const std::vector<size_t>& features, 
                  const std::vector<size_t>& samples) const=0;

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

    ///
    /// @return sub-Lookup of the DataLookup2D
    ///
    /// @Note Returns a dynamically allocated DataLookup2D, which has
    /// to be deleted by the caller to avoid memory leaks.
    ///
    virtual const DataLookup2D* 
    validation_data(const std::vector<size_t>& train,
                    const std::vector<size_t>& val) const=0; 

    ///
    /// @return sub-Lookup of the DataLookup2D
    ///
    /// @Note Returns a dynamically allocated DataLookup2D, which has
    /// to be deleted by the caller to avoid memory leaks.
    ///
    virtual const DataLookup2D* 
    validation_data(const std::vector<size_t>& features,
                    const std::vector<size_t>& train,
                    const std::vector<size_t>& val) const=0; 

    ///
    /// Is lookup weighted?
    /// 
    virtual bool weighted(void) const=0;

    ///
    /// @brief access operator
    ///
    /// @return value in that particular element 
    ///
    virtual double operator()(const size_t row, const size_t column) const=0;

  protected:
    const DataLookup2D& operator=(const DataLookup2D&); 

    std::vector<size_t> row_index_;
    std::vector<size_t> column_index_;
    bool owner_;
  };  
  
}} // of namespace classifier and namespace theplu

#endif