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

// $Id$

#ifndef _theplu_classifier_matrix_lookup_ 
#define _theplu_classifier_matrix_lookup_ 

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

#include <cassert>

namespace theplu {
namespace classifier {  

  

  ///
  /// Interface class for classifier data
  ///
  /// @todo document, especially describe when object becomes invalid,
  /// as now documentation is conservative.
  class MatrixLookup : public DataLookup2D
  {
  
  public:


    ///
    /// Constructor creating a lookup into the whole matrix. 
    ///
    /// @note If @a matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    explicit MatrixLookup(const gslapi::matrix& matrix);

    ///
    /// Constructor creating a lookup into parts of matrix. The
    /// \f$i\f$th row in constructed lookup is identical to row number
    /// row[i] in matrix. The \f$i\f$th column in constructed lookup
    /// is identical to column number column[i] in matrix.
    ///
    /// @note If @a matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    MatrixLookup(const gslapi::matrix& matrix, const std::vector<size_t>& row, 
             const std::vector<size_t>& column);

    ///
    /// Constructor taking rows or columns 
    ///
    /// @parameter row_vectors if true (default) the new MatrixLookup
    /// will look into a sub-matrix defined by all columns and rows
    /// defined by @a index. If not true the new MatrixLookup will
    /// look into a sub-matrix defined by all rows and columns defined
    /// by @a index.
    ///
    /// @note If @a matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    MatrixLookup(const gslapi::matrix& matrix, 
                 const std::vector<size_t>& index, 
                 const bool row_vectors=true);

    ///
    /// @brief Copy constructor.
    ///
    /// @note If underlying matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    MatrixLookup(const MatrixLookup&);

    ///
    /// Constructor taking the row index vector and column index vector 
    /// as input. 
    ///
    /// @note If underlying matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    MatrixLookup(const MatrixLookup& matrix, const std::vector<size_t>&, 
             const std::vector<size_t>&);

    ///
    /// Constructor taking the column (default) or row index vector as
    /// input. If @a row is false the created MatrixLookup will have
    /// equally many rows as @a matrix.
    ///
    /// @note If underlying matrix goes out of scope or is deleted, the
    /// MatrixLookup becomes invalid and the result of further use is
    /// undefined.
    ///
    MatrixLookup(const MatrixLookup& matrix, const std::vector<size_t>&, 
                 const bool row=false);

    ///
    /// Constructor creating a MatrixLookup with @a rows rows, @a
    /// columns columns, and all values are set to @a value. Created
    /// object owns its underlying matrix.
    ///
    MatrixLookup(const size_t rows, const size_t columns, const double value=0);

    ///
    /// Destructor
    ///
    virtual ~MatrixLookup();

    
    ///
    /// @return pointer to sub-Lookup of the MatrixLookup
    ///
    /// @note If underlying matrix goes out of scope or is deleted, the
    /// returned pointer becomes invalid and the result of further use is
    /// undefined.
    ///
    const MatrixLookup* training_data(const std::vector<size_t>& i) const;
    
    ///
    /// @return pointer to sub-Lookup of the MatrixLookup
    ///
    /// @note If underlying matrix goes out of scope or is deleted, the
    /// returned pointer becomes invalid and the result of further use is
    /// undefined.
    ///
    const MatrixLookup* validation_data(const std::vector<size_t>&,
                                        const std::vector<size_t>&) const;
    ///
    /// Access operator
    ///
    /// @return element 
    ///
    inline double operator()(const size_t row, const size_t column) const
    { 
      assert(row<rows());
      assert(columns());
      return (*data_)(row_index_[row], column_index_[column]); 
    }

  private:
    const gslapi::matrix* data_;
  };  
  
  ///
  /// The output operator MatrixLookup
  ///
  std::ostream& operator<< (std::ostream& s, const MatrixLookup&);

}} // of namespace classifier and namespace theplu

#endif