source: trunk/yat/classifier/MatrixLookupWeighted.cc @ 1587

// $Id$

/*
  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 "MatrixLookupWeighted.h"
#include "MatrixLookup.h"
#include "yat/utility/DataIterator.h"
#include "yat/utility/Matrix.h"
#include "yat/utility/MatrixWeighted.h"
#include "yat/utility/WeightIterator.h"

#include <algorithm>
#include <cassert>
#include <fstream>
#include <vector>

namespace theplu {
namespace yat {
namespace classifier {

  MatrixLookupWeighted::MatrixLookupWeighted(const utility::MatrixWeighted& m,
                                             const utility::Index& rows,
                                             const utility::Index& columns)
    : column_index_(columns), data_(MatrixWP(&m,false)), row_index_(rows)
  {
    assert(validate());
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::MatrixWeighted& m,
                                             bool owner)
    : column_index_(utility::Index(m.columns())), 
      data_(MatrixWP(&m,owner)), 
      row_index_(utility::Index(m.rows()))
  {
    assert(validate());
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
    : column_index_(ml.column_index_), 
      row_index_(ml.row_index_)
  { 
    utility::MatrixWeighted* mw = new utility::MatrixWeighted(*ml.data_);
    data_ = MatrixWP(mw);
    assert(validate());
  }
  

  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
    : column_index_(other.column_index_), data_(other.data_), 
      row_index_(other.row_index_)
  {
    assert(validate());
  }



  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other,
                                             const utility::Index& row, 
                                             const utility::Index& col)
    : column_index_(utility::Index(other.column_index_, col)), 
      data_(other.data_), row_index_(utility::Index(other.row_index_, row))
  {
    assert(validate());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other, 
                                             const utility::Index& index, 
                                             bool row)
    : data_(other.data_)
  {
    if (row){
      row_index_ = utility::Index(other.row_index_, index);
      column_index_= other.column_index_;
    }
    else{
      column_index_ = utility::Index(other.column_index_, index);
      row_index_= other.row_index_;
    }
    assert(validate());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const size_t rows, 
                                             const size_t columns, 
                                             const double value,
                                             const double weight)
    : column_index_(utility::Index(std::vector<size_t>(rows, 0))),
      data_(MatrixWP(new utility::MatrixWeighted(1,1,value, weight))),
      row_index_(utility::Index(std::vector<size_t>(columns, 0)))
  {
    assert(validate());
  }

  
  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
    : data_(MatrixWP(new utility::MatrixWeighted(is,sep)))
  {
    column_index_ = utility::Index(data_->columns());
    row_index_ = utility::Index(data_->rows());
    assert(validate());
  }
  

  MatrixLookupWeighted::~MatrixLookupWeighted(void)
  {
  }



  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::begin(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
  }


  MatrixLookupWeighted::const_column_iterator 
  MatrixLookupWeighted::begin_column(size_t i) const
  {
    return const_column_iterator(const_column_iterator::iterator_type(*this,0, 
                                                                      i),
                                 columns());
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::begin_row(size_t i) const
  {
    return const_row_iterator(const_row_iterator::iterator_type(*this,i, 0), 1);
  }


  size_t MatrixLookupWeighted::columns(void) const
  {
    return column_index_.size();
  }


  double MatrixLookupWeighted::data(size_t row, size_t column) const
  {
    assert(row<rows());
    assert(column<columns());
    assert(row_index_[row]<data_->rows());
    assert(column_index_[column]<data_->columns());
    return (*this)(row, column).data();
  }



  MatrixLookupWeighted::const_iterator MatrixLookupWeighted::end(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
  }


  MatrixLookupWeighted::const_iterator 
  MatrixLookupWeighted::end_column(size_t i) const
  {
    return const_column_iterator(const_column_iterator::iterator_type(*this, 
                                                                      rows(),i),
                                 columns());
  }


  MatrixLookupWeighted::const_row_iterator 
  MatrixLookupWeighted::end_row(size_t i) const
  {
    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
  }


  size_t MatrixLookupWeighted::rows(void) const
  {
    return row_index_.size();
  }


  bool MatrixLookupWeighted::validate(void) const
  {
    for (size_t i=0; i<row_index_.size(); ++i)
      if (row_index_[i]>=data_->rows()) {
        std::cerr << i << " " << row_index_[i] << std::endl;
        return false;
      }
    for (size_t i=0; i<column_index_.size(); ++i)
      if (column_index_[i]>=data_->columns())
        return false;
    return true;
  }


  double MatrixLookupWeighted::weight(size_t row, size_t column) const
  {
    assert(row<rows());
    assert(column<columns());
    return (*this)(row, column).weight();
  }



  bool MatrixLookupWeighted::weighted(void) const 
  {
    return true;
  }



  MatrixLookupWeighted::const_reference
  MatrixLookupWeighted::operator()(const size_t row, const size_t column) const
  { 
    return (*data_)(row_index_[row], column_index_[column]);
  }



  const MatrixLookupWeighted& MatrixLookupWeighted::operator=
  (const MatrixLookupWeighted& other)
  {
    if (this!=&other){
      column_index_=other.column_index_;
      row_index_=other.row_index_;
      data_ = other.data_;
    }
    assert(validate());
    return *this;
  }


}}} // of namespace classifier, yat, and theplu