source: trunk/yat/classifier/DataLookup1D.h @ 1525

#ifndef _theplu_yat_classifier_dataLookup1D_ 
#define _theplu_yat_classifier_dataLookup1D_ 

// $Id$

/*
  Copyright (C) 2005 Peter Johansson
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "MatrixLookup.h"

#include <iostream>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {
  class VectorBase;
}
namespace classifier {  

  ///
  /// @brief Class for general vector view. 
  ///
  class DataLookup1D
  {
  public:
    /// 'Read Only' iterator
    typedef MatrixLookup::const_row_iterator const_iterator;

    ///
    /// Constructor. 
    ///
    /// \param m MatrixLookup to look into
    /// @param row_vector if true DataLookup1D is looking into a
    /// row of MatrixLookup, otherwise looking into a
    /// column. @param index which row/column to look into.
    ///
    DataLookup1D(const MatrixLookup& m, const size_t index, 
                 const bool row_vector);

    ///
    /// Copy constructor
    ///
    DataLookup1D(const DataLookup1D&);

    ///
    /// Construct DataLookup1D that owns its underlying matrix. Object
    /// has size @ size and all its element is equal to @a value.
    ///
    DataLookup1D(const size_t size, const double value=0); 

    /**
       @brief Create general view from utility::VectorBase
    
       Constructor creates a proper MatrixLookup that object can view
       into. Object is owner of this underlying MatrixLookup. Object fulfills 
       \f$ x(i) = vec(index(i)) \f$
    */
    DataLookup1D(const utility::VectorBase& vec, 
                 const std::vector<size_t>& index); 

    /**
       @brief Create general view from utility::VectorBase
    
       Constructor creates a proper MatrixLookup that object can view
       into. Object is owner of this underlying MatrixLookup. Object fulfills 
       \f$ x(i) = vec(i) \f$
    */
    DataLookup1D(const utility::VectorBase& vec); 

    ///
    /// @brief Destructor deletes underlying MatrixLookup if object is owner 
    ///
    virtual ~DataLookup1D();

    /**
       \return 'Read Only' iterator to first element.
     */
    const_iterator begin() const;

    /**
       \return 'Read Only' iterator to end of DataLookup1D.
     */
    const_iterator end() const;

    ///
    /// @return number of elements
    ///
    size_t size(void) const;

    ///
    /// @brief access operator
    ///
    double operator()(const size_t i) const;

    ///
    /// scalar product
    ///
    double operator*(const DataLookup1D&) const;

  private:
    // assignment no allowed
    const DataLookup1D& operator=(const DataLookup1D&);

    const bool column_vector_;
    const size_t index_;
    const MatrixLookup* matrix_;
    const bool owner_;
    
  };

  ///
  /// @brief The output operator for DataLookup1D.
  ///
  /**
   * Elements are separated by the character from the omanip fill.
   * The following example will write the elements separated by tab.
   * 
   @verbatim 
   char prev=s.fill('\t'); 
   s << v;
   s.fill(prev); 
   @endverbatim
  */
  std::ostream& operator<<(std::ostream& s, const DataLookup1D& v);
  
}}} // of namespace classifier, yat, and theplu

#endif