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

// $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), row_index_(rows)
  {
    utility::Matrix* data = new utility::Matrix(m.rows(), m.columns());
    utility::Matrix* weight = new utility::Matrix(m.rows(), m.columns());
    for (size_t i=0; i<m.rows(); ++i)
      for (size_t j=0; j<m.columns(); ++j) {
        (*data)(i,j) = m(i,j).data();
        (*weight)(i,j) = m(i,j).weight();
      }
    // smart pointers are taking ownership
    data_ = MatrixP(data);
    weights_ = MatrixP(weight);
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::MatrixWeighted& m,
                                             bool owner)
    : column_index_(utility::Index(m.columns())), 
      row_index_(utility::Index(m.rows()))
  {
    // Peter, remember to take care of ownership (but for now leave a leak)

    utility::Matrix* data = new utility::Matrix(m.rows(), m.columns());
    utility::Matrix* weight = new utility::Matrix(m.rows(), m.columns());
    for (size_t i=0; i<m.rows(); ++i)
      for (size_t j=0; j<m.columns(); ++j) {
        (*data)(i,j) = m(i,j).data();
        (*weight)(i,j) = m(i,j).weight();
      } 
  // smart pointers are taking ownership
    data_ = MatrixP(data);
    weights_ = MatrixP(weight);
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
                                             const utility::Matrix& weights,
                                             const bool own)
    : data_(MatrixP(&data, own)), weights_(MatrixP(&weights, own)) 
  {
    assert(data.rows()==weights.rows());
    assert(data.columns()==weights.columns());
    row_index_ = utility::Index(data.rows());
    column_index_ = utility::Index(data.columns());
    assert(validate());
  }


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& ml)
    : column_index_(ml.column_index_), data_(ml.data_),
      row_index_(ml.row_index_), 
      weights_(MatrixP(new utility::Matrix(data_->rows(),data_->columns(),1.0)))
  { 
    assert(validate());
  }
  

  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
                                             const utility::Matrix& weights, 
                                             const utility::Index& row, 
                                             const utility::Index& col)
    : column_index_(col), data_(MatrixP(&data, false)), 
      row_index_(row), weights_(MatrixP(&weights, false))
  {
    assert(validate());
  }
  


  /*
  MatrixLookupWeighted::MatrixLookupWeighted(const utility::Matrix& data, 
                                             const utility::Matrix& weights, 
                                             const utility::Index& index, 
                                             const bool row)
    : data_(MatrixP(new utility::Matrix(data), false)), 
      weights_(MatrixP(new utility::Matrix(weights), false))
  {
    assert(data.rows()==weights.rows());
    assert(data.columns()==weights.columns());
    if (row){
      row_index_=index;
      column_index_ = utility::Index(data.columns());
    }
    else{
      column_index_=index;
      row_index_ = utility::Index(data.rows());
    }
    assert(validate());
  }
  */

  /*
  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookup& dv,
                                             const MatrixLookup& wv)
    : DataLookup2D(dv), data_(dv.data_), weights_(dv.data_)
  {
  }
  */


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other)
    : column_index_(other.column_index_), data_(other.data_), 
      row_index_(other.row_index_), weights_(other.weights_)
  {
    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)), 
      weights_(other.weights_)
  {
    assert(validate());
  }
  


  MatrixLookupWeighted::MatrixLookupWeighted(const MatrixLookupWeighted& other, 
                                             const utility::Index& index, 
                                             bool row)
    : data_(other.data_), 
      weights_(other.weights_)
  {
    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_(MatrixP(new utility::Matrix(1,1,value))),
      row_index_(utility::Index(std::vector<size_t>(columns, 0))), 
      weights_(MatrixP(new utility::Matrix(1,1,weight)))
  {
    assert(validate());
  }

  
  MatrixLookupWeighted::MatrixLookupWeighted(std::istream& is, char sep)
    : data_(MatrixP(new utility::Matrix(is,sep)))
  {
    column_index_ = utility::Index(data_->columns());
    row_index_ = utility::Index(data_->rows());
    utility::Matrix weights;
    utility::nan(*data_,weights);
    // Peter, should be possible to avoid this copying
    weights_= MatrixP(new utility::Matrix(weights));
    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 (*data_)(row_index_[row], column_index_[column]);
  }



  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;
    for (size_t i=0; i<row_index_.size(); ++i)
      if (row_index_[i]>=weights_->rows())
        return false;
    for (size_t i=0; i<column_index_.size(); ++i)
      if (column_index_[i]>=weights_->columns())
        return false;
    return true;
  }


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



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



  MatrixLookupWeighted::const_reference
  MatrixLookupWeighted::operator()(const size_t row, const size_t column) const
  { 
    return utility::DataWeight(data(row, column), weight(row,column));
  }



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


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